bundles/org.simantics.db/src/org/simantics/db/AsyncReadGraph.java

   1 /*******************************************************************************\r
   2  * Copyright (c) 2007, 2010 Association for Decentralized Information Management\r
   3  * in Industry THTH ry.\r
   4  * All rights reserved. This program and the accompanying materials\r
   5  * are made available under the terms of the Eclipse Public License v1.0\r
   6  * which accompanies this distribution, and is available at\r
   7  * http://www.eclipse.org/legal/epl-v10.html\r
   8  *\r
   9  * Contributors:\r
  10  *     VTT Technical Research Centre of Finland - initial API and implementation\r
  11  *******************************************************************************/\r
  12 package org.simantics.db;\r
  13 \r
  14 import java.util.Set;\r
  15 \r
  16 import org.simantics.databoard.binding.Binding;\r
  17 import org.simantics.db.exception.DatabaseException;\r
  18 import org.simantics.db.procedure.AsyncListener;\r
  19 import org.simantics.db.procedure.AsyncMultiListener;\r
  20 import org.simantics.db.procedure.AsyncMultiProcedure;\r
  21 import org.simantics.db.procedure.AsyncProcedure;\r
  22 import org.simantics.db.procedure.AsyncSetListener;\r
  23 import org.simantics.db.procedure.Listener;\r
  24 import org.simantics.db.procedure.MultiListener;\r
  25 import org.simantics.db.procedure.MultiProcedure;\r
  26 import org.simantics.db.procedure.Procedure;\r
  27 import org.simantics.db.procedure.SetListener;\r
  28 import org.simantics.db.procedure.SyncListener;\r
  29 import org.simantics.db.procedure.SyncMultiListener;\r
  30 import org.simantics.db.procedure.SyncMultiProcedure;\r
  31 import org.simantics.db.procedure.SyncProcedure;\r
  32 import org.simantics.db.procedure.SyncSetListener;\r
  33 import org.simantics.db.request.MultiRead;\r
  34 import org.simantics.db.request.Read;\r
  35 \r
  36 /**\r
  37  * \r
  38  * For accessing and manipulating the graph data in asynchronous manner. A client\r
  39  * receives AsyncReadGraph instances for performing requests in {@link Read} and\r
  40  * {@link MultiRead} as well as for reacting to request results using\r
  41  * {@link AsyncProcedure}, {@link AsyncListener}, {@link AsyncMultiProcedure},\r
  42  * {@link AsyncMultiListener} and {@link AsyncSetListener}\r
  43  * <p>\r
  44  * AsyncReadGraph instances are stateful and may not be stored and used outside the\r
  45  * supplier method activation. The methods receiving AsyncReadGraph should not block for long\r
  46  * periods of time since that may delay the processing of other requests. For a\r
  47  * synchronous counterpart with the same functionality as AsyncReadGraph see\r
  48  * {@link ReadGraph}\r
  49  * \r
  50  * @version 0.7\r
  51  * @author Antti Villberg\r
  52  * @see RequestProcessor\r
  53  * @see AsyncRequestProcessor\r
  54  * @see ReadGraph\r
  55  * @see Resource\r
  56  * @see Statement\r
  57  */\r
  58 public interface AsyncReadGraph extends AsyncRequestProcessor {\r
  59 \r
  60     /**\r
  61      * @see ReadGraph#getURI(Resource)\r
  62      */\r
  63     void forURI(Resource resource, AsyncListener<String> procedure);\r
  64     /**\r
  65      * @see ReadGraph#getURI(Resource)\r
  66      */\r
  67     void forURI(Resource resource, SyncListener<String> procedure);\r
  68     /**\r
  69      * @see ReadGraph#getURI(Resource)\r
  70      */\r
  71     void forURI(Resource resource, Listener<String> procedure);\r
  72     /**\r
  73      * @see ReadGraph#getURI(Resource)\r
  74      */\r
  75     void forURI(Resource resource, AsyncProcedure<String> procedure);\r
  76     /**\r
  77      * @see ReadGraph#getURI(Resource)\r
  78      */\r
  79     void forURI(Resource resource, SyncProcedure<String> procedure);\r
  80     /**\r
  81      * @see ReadGraph#getURI(Resource)\r
  82      */\r
  83     void forURI(Resource resource, Procedure<String> procedure);\r
  84 \r
  85     /**\r
  86      * @see ReadGraph#getResourceByURI(String)\r
  87      */\r
  88     void forResource(String id, AsyncListener<Resource> procedure);\r
  89     /**\r
  90      * @see ReadGraph#getResourceByURI(String)\r
  91      */\r
  92     void forResource(String id, SyncListener<Resource> procedure);\r
  93     /**\r
  94      * @see ReadGraph#getResourceByURI(String)\r
  95      */\r
  96     void forResource(String id, Listener<Resource> procedure);\r
  97     /**\r
  98      * @see ReadGraph#getResourceByURI(String)\r
  99      */\r
 100     void forResource(String id, AsyncProcedure<Resource> procedure);\r
 101     /**\r
 102      * @see ReadGraph#getResourceByURI(String)\r
 103      */\r
 104     void forResource(String id, SyncProcedure<Resource> procedure);\r
 105     /**\r
 106      * @see ReadGraph#getResourceByURI(String)\r
 107      */\r
 108     void forResource(String id, Procedure<Resource> procedure);\r
 109 \r
 110     /**\r
 111      * @see ReadGraph#getBuiltin(String)\r
 112      */\r
 113     void forBuiltin(String id, AsyncListener<Resource> procedure);\r
 114     /**\r
 115      * @see ReadGraph#getBuiltin(String)\r
 116      */\r
 117     void forBuiltin(String id, SyncListener<Resource> procedure);\r
 118     /**\r
 119      * @see ReadGraph#getBuiltin(String)\r
 120      */\r
 121     void forBuiltin(String id, Listener<Resource> procedure);\r
 122     /**\r
 123      * @see ReadGraph#getBuiltin(String)\r
 124      */\r
 125     void forBuiltin(String id, AsyncProcedure<Resource> procedure);\r
 126     /**\r
 127      * @see ReadGraph#getBuiltin(String)\r
 128      */\r
 129     void forBuiltin(String id, SyncProcedure<Resource> procedure);\r
 130     /**\r
 131      * @see ReadGraph#getBuiltin(String)\r
 132      */\r
 133     void forBuiltin(String id, Procedure<Resource> procedure);\r
 134 \r
 135     /**\r
 136      * @see ReadGraph#getStatements(Resource, Resource)\r
 137      */\r
 138     void forEachStatement(Resource subject, Resource relation, AsyncMultiProcedure<Statement> procedure);\r
 139     /**\r
 140      * @see ReadGraph#getStatements(Resource, Resource)\r
 141      */\r
 142     void forEachStatement(Resource subject, Resource relation, SyncMultiProcedure<Statement> procedure);\r
 143     /**\r
 144      * @see ReadGraph#getStatements(Resource, Resource)\r
 145      */\r
 146     void forEachStatement(Resource subject, Resource relation, MultiProcedure<Statement> procedure);\r
 147 \r
 148     /**\r
 149      * @see ReadGraph#getStatements(Resource, Resource)\r
 150      */\r
 151     void forStatementSet(Resource subject, Resource relation, AsyncSetListener<Statement> procedure);\r
 152     /**\r
 153      * @see ReadGraph#getStatements(Resource, Resource)\r
 154      */\r
 155     void forStatementSet(Resource subject, Resource relation, SyncSetListener<Statement> procedure);\r
 156     /**\r
 157      * @see ReadGraph#getStatements(Resource, Resource)\r
 158      */\r
 159     void forStatementSet(Resource subject, Resource relation, SetListener<Statement> procedure);\r
 160 \r
 161     /**\r
 162      * @see ReadGraph#getAssertedStatements(Resource, Resource)\r
 163      */\r
 164     void forEachAssertedStatement(Resource subject, Resource relation, AsyncMultiProcedure<Statement> procedure);\r
 165     /**\r
 166      * @see ReadGraph#getAssertedStatements(Resource, Resource)\r
 167      */\r
 168     void forEachAssertedStatement(Resource subject, Resource relation, SyncMultiProcedure<Statement> procedure);\r
 169     /**\r
 170      * @see ReadGraph#getAssertedStatements(Resource, Resource)\r
 171      */\r
 172     void forEachAssertedStatement(Resource subject, Resource relation, MultiProcedure<Statement> procedure);\r
 173 \r
 174     /**\r
 175      * @see ReadGraph#getAssertedStatements(Resource, Resource)\r
 176      */\r
 177     void forAssertedStatementSet(Resource subject, Resource relation, AsyncSetListener<Statement> procedure);\r
 178     /**\r
 179      * @see ReadGraph#getAssertedStatements(Resource, Resource)\r
 180      */\r
 181     void forAssertedStatementSet(Resource subject, Resource relation, SyncSetListener<Statement> procedure);\r
 182     /**\r
 183      * @see ReadGraph#getAssertedStatements(Resource, Resource)\r
 184      */\r
 185     void forAssertedStatementSet(Resource subject, Resource relation, SetListener<Statement> procedure);\r
 186 \r
 187     /**\r
 188      * @see ReadGraph#getPredicates(Resource)\r
 189      */\r
 190     void forEachPredicate(Resource subject, AsyncMultiProcedure<Resource> procedure);\r
 191     /**\r
 192      * @see ReadGraph#getPredicates(Resource)\r
 193      */\r
 194     void forEachPredicate(Resource subject, SyncMultiProcedure<Resource> procedure);\r
 195     /**\r
 196      * @see ReadGraph#getPredicates(Resource)\r
 197      */\r
 198     void forEachPredicate(Resource subject, MultiProcedure<Resource> procedure);\r
 199 \r
 200     /**\r
 201      * @see ReadGraph#getPredicates(Resource)\r
 202      */\r
 203     void forPredicateSet(Resource subject, AsyncSetListener<Resource> procedure);\r
 204     /**\r
 205      * @see ReadGraph#getPredicates(Resource)\r
 206      */\r
 207     void forPredicateSet(Resource subject, SyncSetListener<Resource> procedure);\r
 208     /**\r
 209      * @see ReadGraph#getPredicates(Resource)\r
 210      */\r
 211     void forPredicateSet(Resource subject, SetListener<Resource> procedure);\r
 212 \r
 213     /**\r
 214      * @see ReadGraph#getPrincipalTypes(Resource)\r
 215      */\r
 216     void forEachPrincipalType(Resource subject, AsyncMultiProcedure<Resource> procedure);\r
 217     /**\r
 218      * @see ReadGraph#getPrincipalTypes(Resource)\r
 219      */\r
 220     void forEachPrincipalType(Resource subject, SyncMultiProcedure<Resource> procedure);\r
 221     /**\r
 222      * @see ReadGraph#getPrincipalTypes(Resource)\r
 223      */\r
 224     void forEachPrincipalType(Resource subject, MultiProcedure<Resource> procedure);\r
 225 \r
 226     /**\r
 227      * @see ReadGraph#getPrincipalTypes(Resource)\r
 228      */\r
 229     void forPrincipalTypeSet(Resource subject, AsyncSetListener<Resource> procedure);\r
 230     /**\r
 231      * @see ReadGraph#getPrincipalTypes(Resource)\r
 232      */\r
 233     void forPrincipalTypeSet(Resource subject, SyncSetListener<Resource> procedure);\r
 234     /**\r
 235      * @see ReadGraph#getPrincipalTypes(Resource)\r
 236      */\r
 237     void forPrincipalTypeSet(Resource subject, SetListener<Resource> procedure);\r
 238 \r
 239     /**\r
 240      * @see ReadGraph#getTypes(Resource)\r
 241      */\r
 242     void forTypes(Resource subject, AsyncListener<Set<Resource>> procedure);\r
 243     /**\r
 244      * @see ReadGraph#getTypes(Resource)\r
 245      */\r
 246     void forTypes(Resource subject, SyncListener<Set<Resource>> procedure);\r
 247     /**\r
 248      * @see ReadGraph#getTypes(Resource)\r
 249      */\r
 250     void forTypes(Resource subject, Listener<Set<Resource>> procedure);\r
 251     /**\r
 252      * @see ReadGraph#getTypes(Resource)\r
 253      */\r
 254     void forTypes(Resource subject, AsyncProcedure<Set<Resource>> procedure);\r
 255     /**\r
 256      * @see ReadGraph#getTypes(Resource)\r
 257      */\r
 258     void forTypes(Resource subject, SyncProcedure<Set<Resource>> procedure);\r
 259     /**\r
 260      * @see ReadGraph#getTypes(Resource)\r
 261      */\r
 262     void forTypes(Resource subject, Procedure<Set<Resource>> procedure);\r
 263 \r
 264     /**\r
 265      * @see ReadGraph#getSupertypes(Resource)\r
 266      */\r
 267     void forSupertypes(Resource subject, AsyncListener<Set<Resource>> procedure);\r
 268     /**\r
 269      * @see ReadGraph#getSupertypes(Resource)\r
 270      */\r
 271     void forSupertypes(Resource subject, SyncListener<Set<Resource>> procedure);\r
 272     /**\r
 273      * @see ReadGraph#getSupertypes(Resource)\r
 274      */\r
 275     void forSupertypes(Resource subject, Listener<Set<Resource>> procedure);\r
 276     /**\r
 277      * @see ReadGraph#getSupertypes(Resource)\r
 278      */\r
 279     void forSupertypes(Resource subject, AsyncProcedure<Set<Resource>> procedure);\r
 280     /**\r
 281      * @see ReadGraph#getSupertypes(Resource)\r
 282      */\r
 283     void forSupertypes(Resource subject, SyncProcedure<Set<Resource>> procedure);\r
 284     /**\r
 285      * @see ReadGraph#getSupertypes(Resource)\r
 286      */\r
 287     void forSupertypes(Resource subject, Procedure<Set<Resource>> procedure);\r
 288 \r
 289     /**\r
 290      * @see ReadGraph#getSuperrelations(Resource)\r
 291      */\r
 292     void forDirectSuperrelations(Resource subject, AsyncMultiProcedure<Resource> procedure);\r
 293 \r
 294     /**\r
 295      * @see ReadGraph#getSuperrelations(Resource)\r
 296      */\r
 297     void forPossibleSuperrelation(Resource subject, AsyncProcedure<Resource> procedure);\r
 298 \r
 299     /**\r
 300      * @see ReadGraph#getSuperrelations(Resource)\r
 301      */\r
 302     void forSuperrelations(Resource subject, AsyncListener<Set<Resource>> procedure);\r
 303     /**\r
 304      * @see ReadGraph#getSuperrelations(Resource)\r
 305      */\r
 306     void forSuperrelations(Resource subject, SyncListener<Set<Resource>> procedure);\r
 307     /**\r
 308      * @see ReadGraph#getSuperrelations(Resource)\r
 309      */\r
 310     void forSuperrelations(Resource subject, Listener<Set<Resource>> procedure);\r
 311     /**\r
 312      * @see ReadGraph#getSuperrelations(Resource)\r
 313      */\r
 314     void forSuperrelations(Resource subject, AsyncProcedure<Set<Resource>> procedure);\r
 315     /**\r
 316      * @see ReadGraph#getSuperrelations(Resource)\r
 317      */\r
 318     void forSuperrelations(Resource subject, SyncProcedure<Set<Resource>> procedure);\r
 319     /**\r
 320      * @see ReadGraph#getSuperrelations(Resource)\r
 321      */\r
 322     void forSuperrelations(Resource subject, Procedure<Set<Resource>> procedure);\r
 323 \r
 324     /**\r
 325      * \r
 326      * If relation is functional this do one of the following\r
 327      * -call execute 0 or 1 times and then call finished\r
 328      * -call exception with ManyObjectsForFunctionalRelation\r
 329      * \r
 330      * @see ReadGraph#getObjects(Resource, Resource)\r
 331      */\r
 332     void forEachObject(Resource subject, Resource relation, AsyncMultiProcedure<Resource> procedure);\r
 333     /**\r
 334      * @see ReadGraph#getObjects(Resource, Resource)\r
 335      */\r
 336     void forEachObject(Resource subject, Resource relation, SyncMultiProcedure<Resource> procedure);\r
 337     /**\r
 338      * @see ReadGraph#getObjects(Resource, Resource)\r
 339      */\r
 340     void forEachObject(Resource subject, Resource relation, MultiProcedure<Resource> procedure);\r
 341 \r
 342     /**\r
 343      * @see ReadGraph#getObjects(Resource, Resource)\r
 344      */\r
 345 //    void forEachDirectObject(Resource subject, Resource relation, AsyncMultiProcedure<Resource> procedure);\r
 346 //    /**\r
 347 //     * @see ReadGraph#getObjects(Resource, Resource)\r
 348 //     */\r
 349 //    void forEachDirectObject(Resource subject, Resource relation, SyncMultiProcedure<Resource> procedure);\r
 350 //    /**\r
 351 //     * @see ReadGraph#getObjects(Resource, Resource)\r
 352 //     */\r
 353 //    void forEachDirectObject(Resource subject, Resource relation, MultiProcedure<Resource> procedure);\r
 354 \r
 355     /**\r
 356      * @see ReadGraph#getObjects(Resource, Resource)\r
 357      */\r
 358     void forEachDirectPredicate(Resource subject, AsyncMultiProcedure<Resource> procedure);\r
 359     /**\r
 360      * @see ReadGraph#getObjects(Resource, Resource)\r
 361      */\r
 362     void forEachDirectPredicate(Resource subject, SyncMultiProcedure<Resource> procedure);\r
 363     /**\r
 364      * @see ReadGraph#getObjects(Resource, Resource)\r
 365      */\r
 366     void forEachDirectPredicate(Resource subject, MultiProcedure<Resource> procedure);\r
 367 \r
 368     /**\r
 369      * @see ReadGraph#getObjects(Resource, Resource)\r
 370      */\r
 371     void forObjectSet(Resource subject, Resource relation, AsyncSetListener<Resource> procedure);\r
 372     /**\r
 373      * @see ReadGraph#getObjects(Resource, Resource)\r
 374      */\r
 375     void forObjectSet(Resource subject, Resource relation, SyncSetListener<Resource> procedure);\r
 376     /**\r
 377      * @see ReadGraph#getObjects(Resource, Resource)\r
 378      */\r
 379     void forObjectSet(Resource subject, Resource relation, SetListener<Resource> procedure);\r
 380 \r
 381     /**\r
 382      * @see ReadGraph#getAssertedObjects(Resource, Resource)\r
 383      */\r
 384     void forEachAssertedObject(Resource subject, Resource relation, AsyncMultiProcedure<Resource> procedure);\r
 385     /**\r
 386      * @see ReadGraph#getAssertedObjects(Resource, Resource)\r
 387      */\r
 388     void forEachAssertedObject(Resource subject, Resource relation, SyncMultiProcedure<Resource> procedure);\r
 389     /**\r
 390      * @see ReadGraph#getAssertedObjects(Resource, Resource)\r
 391      */\r
 392     void forEachAssertedObject(Resource subject, Resource relation, MultiProcedure<Resource> procedure);\r
 393 \r
 394     /**\r
 395      * @see ReadGraph#getAssertedObjects(Resource, Resource)\r
 396      */\r
 397     void forAssertedObjectSet(Resource subject, Resource relation, AsyncSetListener<Resource> procedure);\r
 398     /**\r
 399      * @see ReadGraph#getAssertedObjects(Resource, Resource)\r
 400      */\r
 401     void forAssertedObjectSet(Resource subject, Resource relation, SyncSetListener<Resource> procedure);\r
 402     /**\r
 403      * @see ReadGraph#getAssertedObjects(Resource, Resource)\r
 404      */\r
 405     void forAssertedObjectSet(Resource subject, Resource relation, SetListener<Resource> procedure);\r
 406 \r
 407     /**\r
 408      * @see ReadGraph#getInverse(Resource)\r
 409      */\r
 410     void forInverse(Resource relation, AsyncListener<Resource> procedure);\r
 411     /**\r
 412      * @see ReadGraph#getInverse(Resource)\r
 413      */\r
 414     void forInverse(Resource relation, SyncListener<Resource> procedure);\r
 415     /**\r
 416      * @see ReadGraph#getInverse(Resource)\r
 417      */\r
 418     void forInverse(Resource relation, Listener<Resource> procedure);\r
 419     /**\r
 420      * @see ReadGraph#getInverse(Resource)\r
 421      */\r
 422     void forInverse(Resource relation, AsyncProcedure<Resource> procedure);\r
 423     /**\r
 424      * @see ReadGraph#getInverse(Resource)\r
 425      */\r
 426     void forInverse(Resource relation, SyncProcedure<Resource> procedure);\r
 427     /**\r
 428      * @see ReadGraph#getInverse(Resource)\r
 429      */\r
 430     void forInverse(Resource relation, Procedure<Resource> procedure);\r
 431 \r
 432     /**\r
 433      * @see ReadGraph#getSingleObject(Resource, Resource)\r
 434      */\r
 435     void forSingleObject(Resource subject, Resource relation, AsyncListener<Resource> procedure);\r
 436     /**\r
 437      * @see ReadGraph#getSingleObject(Resource, Resource)\r
 438      */\r
 439     void forSingleObject(Resource subject, Resource relation, SyncListener<Resource> procedure);\r
 440     /**\r
 441      * @see ReadGraph#getSingleObject(Resource, Resource)\r
 442      */\r
 443     void forSingleObject(Resource subject, Resource relation, Listener<Resource> procedure);\r
 444     /**\r
 445      * @see ReadGraph#getSingleObject(Resource, Resource)\r
 446      */\r
 447     void forSingleObject(Resource subject, Resource relation, AsyncProcedure<Resource> procedure);\r
 448     /**\r
 449      * @see ReadGraph#getSingleObject(Resource, Resource)\r
 450      */\r
 451     void forSingleObject(Resource subject, Resource relation, SyncProcedure<Resource> procedure);\r
 452     /**\r
 453      * @see ReadGraph#getSingleObject(Resource, Resource)\r
 454      */\r
 455     void forSingleObject(Resource subject, Resource relation, Procedure<Resource> procedure);\r
 456 \r
 457     /**\r
 458      * @see ReadGraph#getSingleStatement(Resource, Resource)\r
 459      */\r
 460     void forSingleStatement(Resource subject, Resource relation, AsyncListener<Statement> procedure);\r
 461     /**\r
 462      * @see ReadGraph#getSingleStatement(Resource, Resource)\r
 463      */\r
 464     void forSingleStatement(Resource subject, Resource relation, SyncListener<Statement> procedure);\r
 465     /**\r
 466      * @see ReadGraph#getSingleStatement(Resource, Resource)\r
 467      */\r
 468     void forSingleStatement(Resource subject, Resource relation, Listener<Statement> procedure);\r
 469     /**\r
 470      * @see ReadGraph#getSingleStatement(Resource, Resource)\r
 471      */\r
 472     void forSingleStatement(Resource subject, Resource relation, AsyncProcedure<Statement> procedure);\r
 473     /**\r
 474      * @see ReadGraph#getSingleStatement(Resource, Resource)\r
 475      */\r
 476     void forSingleStatement(Resource subject, Resource relation, SyncProcedure<Statement> procedure);\r
 477     /**\r
 478      * @see ReadGraph#getSingleStatement(Resource, Resource)\r
 479      */\r
 480     void forSingleStatement(Resource subject, Resource relation, Procedure<Statement> procedure);\r
 481 \r
 482     /**\r
 483      * @see ReadGraph#getSingleType(Resource, Resource)\r
 484      */\r
 485     void forSingleType(Resource subject, AsyncListener<Resource> procedure);\r
 486     /**\r
 487      * @see ReadGraph#getSingleType(Resource, Resource)\r
 488      */\r
 489     void forSingleType(Resource subject, SyncListener<Resource> procedure);\r
 490     /**\r
 491      * @see ReadGraph#getSingleType(Resource, Resource)\r
 492      */\r
 493     void forSingleType(Resource subject, Listener<Resource> procedure);\r
 494     /**\r
 495      * @see ReadGraph#getSingleType(Resource, Resource)\r
 496      */\r
 497     void forSingleType(Resource subject, AsyncProcedure<Resource> procedure);\r
 498     /**\r
 499      * @see ReadGraph#getSingleType(Resource, Resource)\r
 500      */\r
 501     void forSingleType(Resource subject, SyncProcedure<Resource> procedure);\r
 502     /**\r
 503      * @see ReadGraph#getSingleType(Resource, Resource)\r
 504      */\r
 505     void forSingleType(Resource subject, Procedure<Resource> procedure);\r
 506 \r
 507     /**\r
 508      * @see ReadGraph#getSingleType(Resource, Resource)\r
 509      */\r
 510     void forSingleType(Resource subject, Resource baseType, AsyncListener<Resource> procedure);\r
 511     /**\r
 512      * @see ReadGraph#getSingleType(Resource, Resource)\r
 513      */\r
 514     void forSingleType(Resource subject, Resource baseType, SyncListener<Resource> procedure);\r
 515     /**\r
 516      * @see ReadGraph#getSingleType(Resource, Resource)\r
 517      */\r
 518     void forSingleType(Resource subject, Resource baseType, Listener<Resource> procedure);\r
 519     /**\r
 520      * @see ReadGraph#getSingleType(Resource, Resource)\r
 521      */\r
 522     void forSingleType(Resource subject, Resource baseType, AsyncProcedure<Resource> procedure);\r
 523     /**\r
 524      * @see ReadGraph#getSingleType(Resource, Resource)\r
 525      */\r
 526     void forSingleType(Resource subject, Resource baseType, SyncProcedure<Resource> procedure);\r
 527     /**\r
 528      * @see ReadGraph#getSingleType(Resource, Resource)\r
 529      */\r
 530     void forSingleType(Resource subject, Resource baseType, Procedure<Resource> procedure);\r
 531 \r
 532     /**\r
 533      * @see ReadGraph#getValue(Resource)\r
 534      */\r
 535     <T> void forValue(Resource subject, AsyncListener<T> procedure);\r
 536     /**\r
 537      * @see ReadGraph#getValue(Resource)\r
 538      */\r
 539     <T> void forValue(Resource subject, SyncListener<T> procedure);\r
 540     /**\r
 541      * @see ReadGraph#getValue(Resource)\r
 542      */\r
 543     <T> void forValue(Resource subject, Listener<T> procedure);\r
 544     /**\r
 545      * @see ReadGraph#getValue(Resource)\r
 546      */\r
 547     <T> void forValue(Resource subject, AsyncProcedure<T> procedure);\r
 548     /**\r
 549      * @see ReadGraph#getValue(Resource)\r
 550      */\r
 551     <T> void forValue(Resource subject, SyncProcedure<T> procedure);\r
 552     /**\r
 553      * @see ReadGraph#getValue(Resource)\r
 554      */\r
 555     <T> void forValue(Resource subject, Procedure<T> procedure);\r
 556 \r
 557     /**\r
 558      * @see ReadGraph#getValue(Resource)\r
 559      */\r
 560     <T> void forValue(Resource subject, Binding binding, AsyncListener<T> procedure);\r
 561     /**\r
 562      * @see ReadGraph#getValue(Resource)\r
 563      */\r
 564     <T> void forValue(Resource subject, Binding binding, SyncListener<T> procedure);\r
 565     /**\r
 566      * @see ReadGraph#getValue(Resource)\r
 567      */\r
 568     <T> void forValue(Resource subject, Binding binding, Listener<T> procedure);\r
 569     /**\r
 570      * @see ReadGraph#getValue(Resource)\r
 571      */\r
 572     <T> void forValue(Resource subject, Binding binding, AsyncProcedure<T> procedure);\r
 573     /**\r
 574      * @see ReadGraph#getValue(Resource)\r
 575      */\r
 576     <T> void forValue(Resource subject, Binding binding, SyncProcedure<T> procedure);\r
 577     /**\r
 578      * @see ReadGraph#getValue(Resource)\r
 579      */\r
 580     <T> void forValue(Resource subject, Binding binding, Procedure<T> procedure);\r
 581 \r
 582     /**\r
 583      * @see ReadGraph#getRelatedValue(Resource, Resource)\r
 584      */\r
 585     <T> void forRelatedValue(Resource subject, Resource relation, AsyncListener<T> procedure);\r
 586     /**\r
 587      * @see ReadGraph#getRelatedValue(Resource, Resource)\r
 588      */\r
 589     <T> void forRelatedValue(Resource subject, Resource relation, SyncListener<T> procedure);\r
 590     /**\r
 591      * @see ReadGraph#getRelatedValue(Resource, Resource)\r
 592      */\r
 593     <T> void forRelatedValue(Resource subject, Resource relation, Listener<T> procedure);\r
 594     /**\r
 595      * @see ReadGraph#getRelatedValue(Resource, Resource)\r
 596      */\r
 597     <T> void forRelatedValue(Resource subject, Resource relation, AsyncProcedure<T> procedure);\r
 598     /**\r
 599      * @see ReadGraph#getRelatedValue(Resource, Resource)\r
 600      */\r
 601     <T> void forRelatedValue(Resource subject, Resource relation, SyncProcedure<T> procedure);\r
 602     /**\r
 603      * @see ReadGraph#getRelatedValue(Resource, Resource)\r
 604      */\r
 605     <T> void forRelatedValue(Resource subject, Resource relation, Procedure<T> procedure);\r
 606 \r
 607     /**\r
 608      * @see ReadGraph#getRelatedValue(Resource, Resource, Binding)\r
 609      */\r
 610     <T> void forRelatedValue(Resource subject, Resource relation, Binding binding, AsyncListener<T> procedure);\r
 611     /**\r
 612      * @see ReadGraph#getRelatedValue(Resource, Resource, Binding)\r
 613      */\r
 614     <T> void forRelatedValue(Resource subject, Resource relation, Binding binding, SyncListener<T> procedure);\r
 615     /**\r
 616      * @see ReadGraph#getRelatedValue(Resource, Resource, Binding)\r
 617      */\r
 618     <T> void forRelatedValue(Resource subject, Resource relation, Binding binding, Listener<T> procedure);\r
 619     /**\r
 620      * @see ReadGraph#getRelatedValue(Resource, Resource, Binding)\r
 621      */\r
 622     <T> void forRelatedValue(Resource subject, Resource relation, Binding binding, AsyncProcedure<T> procedure);\r
 623     /**\r
 624      * @see ReadGraph#getRelatedValue(Resource, Resource, Binding)\r
 625      */\r
 626     <T> void forRelatedValue(Resource subject, Resource relation, Binding binding, SyncProcedure<T> procedure);\r
 627     /**\r
 628      * @see ReadGraph#getRelatedValue(Resource, Resource, Binding)\r
 629      */\r
 630     <T> void forRelatedValue(Resource subject, Resource relation, Binding binding, Procedure<T> procedure);\r
 631 \r
 632     /**\r
 633      * @see ReadGraph#adapt(Resource, Class)\r
 634      */\r
 635     <T> void forAdapted(Resource resource, Class<T> clazz, AsyncListener<T> procedure);\r
 636     /**\r
 637      * @see ReadGraph#adapt(Resource, Class)\r
 638      */\r
 639     <T> void forAdapted(Resource resource, Class<T> clazz, SyncListener<T> procedure);\r
 640     /**\r
 641      * @see ReadGraph#adapt(Resource, Class)\r
 642      */\r
 643     <T> void forAdapted(Resource resource, Class<T> clazz, Listener<T> procedure);\r
 644     /**\r
 645      * @see ReadGraph#adapt(Resource, Class)\r
 646      */\r
 647     <T> void forAdapted(Resource resource, Class<T> clazz, AsyncProcedure<T> procedure);\r
 648     /**\r
 649      * @see ReadGraph#adapt(Resource, Class)\r
 650      */\r
 651     <T> void forAdapted(Resource resource, Class<T> clazz, SyncProcedure<T> procedure);\r
 652     /**\r
 653      * @see ReadGraph#adapt(Resource, Class)\r
 654      */\r
 655     <T> void forAdapted(Resource resource, Class<T> clazz, Procedure<T> procedure);\r
 656 \r
 657     /**\r
 658      * @see ReadGraph#adapt(Resource, Class)\r
 659      */\r
 660     <T> void forUniqueAdapted(Resource resource, Class<T> clazz, AsyncListener<T> procedure);\r
 661     /**\r
 662      * @see ReadGraph#adapt(Resource, Class)\r
 663      */\r
 664     <T> void forUniqueAdapted(Resource resource, Class<T> clazz, SyncListener<T> procedure);\r
 665     /**\r
 666      * @see ReadGraph#adapt(Resource, Class)\r
 667      */\r
 668     <T> void forUniqueAdapted(Resource resource, Class<T> clazz, Listener<T> procedure);\r
 669     /**\r
 670      * @see ReadGraph#adapt(Resource, Class)\r
 671      */\r
 672     <T> void forUniqueAdapted(Resource resource, Class<T> clazz, AsyncProcedure<T> procedure);\r
 673     /**\r
 674      * @see ReadGraph#adapt(Resource, Class)\r
 675      */\r
 676     <T> void forUniqueAdapted(Resource resource, Class<T> clazz, SyncProcedure<T> procedure);\r
 677     /**\r
 678      * @see ReadGraph#adapt(Resource, Class)\r
 679      */\r
 680     <T> void forUniqueAdapted(Resource resource, Class<T> clazz, Procedure<T> procedure);\r
 681 \r
 682     /**\r
 683      * @see ReadGraph#getPossibleInverse(Resource)\r
 684      */\r
 685     void forPossibleInverse(Resource relation, AsyncListener<Resource> procedure);\r
 686     /**\r
 687      * @see ReadGraph#getPossibleInverse(Resource)\r
 688      */\r
 689     void forPossibleInverse(Resource relation, SyncListener<Resource> procedure);\r
 690     /**\r
 691      * @see ReadGraph#getPossibleInverse(Resource)\r
 692      */\r
 693     void forPossibleInverse(Resource relation, Listener<Resource> procedure);\r
 694     /**\r
 695      * @see ReadGraph#getPossibleInverse(Resource)\r
 696      */\r
 697     void forPossibleInverse(Resource relation, AsyncProcedure<Resource> procedure);\r
 698     /**\r
 699      * @see ReadGraph#getPossibleInverse(Resource)\r
 700      */\r
 701     void forPossibleInverse(Resource relation, SyncProcedure<Resource> procedure);\r
 702     /**\r
 703      * @see ReadGraph#getPossibleInverse(Resource)\r
 704      */\r
 705     void forPossibleInverse(Resource relation, Procedure<Resource> procedure);\r
 706 \r
 707     /**\r
 708      * @see ReadGraph#getPossibleObject(Resource, Resource)\r
 709      */\r
 710     void forPossibleObject(Resource subject, Resource relation, AsyncListener<Resource> procedure);\r
 711     /**\r
 712      * @see ReadGraph#getPossibleObject(Resource, Resource)\r
 713      */\r
 714     void forPossibleObject(Resource subject, Resource relation, SyncListener<Resource> procedure);\r
 715     /**\r
 716      * @see ReadGraph#getPossibleObject(Resource, Resource)\r
 717      */\r
 718     void forPossibleObject(Resource subject, Resource relation, Listener<Resource> procedure);\r
 719     /**\r
 720      * @see ReadGraph#getPossibleObject(Resource, Resource)\r
 721      */\r
 722     void forPossibleObject(Resource subject, Resource relation, AsyncProcedure<Resource> procedure);\r
 723     /**\r
 724      * @see ReadGraph#getPossibleObject(Resource, Resource)\r
 725      */\r
 726     void forPossibleObject(Resource subject, Resource relation, SyncProcedure<Resource> procedure);\r
 727     /**\r
 728      * @see ReadGraph#getPossibleObject(Resource, Resource)\r
 729      */\r
 730     void forPossibleObject(Resource subject, Resource relation, Procedure<Resource> procedure);\r
 731 \r
 732     /**\r
 733      * @see ReadGraph#getPossibleStatement(Resource, Resource)\r
 734      */\r
 735     void forPossibleStatement(Resource subject, Resource relation, AsyncListener<Statement> procedure);\r
 736     /**\r
 737      * @see ReadGraph#getPossibleStatement(Resource, Resource)\r
 738      */\r
 739     void forPossibleStatement(Resource subject, Resource relation, SyncListener<Statement> procedure);\r
 740     /**\r
 741      * @see ReadGraph#getPossibleStatement(Resource, Resource)\r
 742      */\r
 743     void forPossibleStatement(Resource subject, Resource relation, Listener<Statement> procedure);\r
 744     /**\r
 745      * @see ReadGraph#getPossibleStatement(Resource, Resource)\r
 746      */\r
 747     void forPossibleStatement(Resource subject, Resource relation, AsyncProcedure<Statement> procedure);\r
 748     /**\r
 749      * @see ReadGraph#getPossibleStatement(Resource, Resource)\r
 750      */\r
 751     void forPossibleStatement(Resource subject, Resource relation, SyncProcedure<Statement> procedure);\r
 752     /**\r
 753      * @see ReadGraph#getPossibleStatement(Resource, Resource)\r
 754      */\r
 755     void forPossibleStatement(Resource subject, Resource relation, Procedure<Statement> procedure);\r
 756 \r
 757     /**\r
 758      * @see ReadGraph#getPossibleType(Resource, Resource)\r
 759      */\r
 760     void forPossibleType(Resource subject, Resource baseType, AsyncListener<Resource> procedure);\r
 761     /**\r
 762      * @see ReadGraph#getPossibleType(Resource, Resource)\r
 763      */\r
 764     void forPossibleType(Resource subject, Resource baseType, SyncListener<Resource> procedure);\r
 765     /**\r
 766      * @see ReadGraph#getPossibleType(Resource, Resource)\r
 767      */\r
 768     void forPossibleType(Resource subject, Resource baseType, Listener<Resource> procedure);\r
 769     /**\r
 770      * @see ReadGraph#getPossibleType(Resource, Resource)\r
 771      */\r
 772     void forPossibleType(Resource subject, Resource baseType, AsyncProcedure<Resource> procedure);\r
 773     /**\r
 774      * @see ReadGraph#getPossibleType(Resource, Resource)\r
 775      */\r
 776     void forPossibleType(Resource subject, Resource baseType, SyncProcedure<Resource> procedure);\r
 777     /**\r
 778      * @see ReadGraph#getPossibleType(Resource, Resource)\r
 779      */\r
 780     void forPossibleType(Resource subject, Resource baseType, Procedure<Resource> procedure);\r
 781 \r
 782     /**\r
 783      * @see ReadGraph#getPossibleValue(Resource)\r
 784      */\r
 785     <T> void forPossibleValue(Resource subject, AsyncListener<T> procedure);\r
 786     /**\r
 787      * @see ReadGraph#getPossibleValue(Resource)\r
 788      */\r
 789     <T> void forPossibleValue(Resource subject, SyncListener<T> procedure);\r
 790     /**\r
 791      * @see ReadGraph#getPossibleValue(Resource)\r
 792      */\r
 793     <T> void forPossibleValue(Resource subject, Listener<T> procedure);\r
 794     /**\r
 795      * @see ReadGraph#getPossibleValue(Resource)\r
 796      */\r
 797     <T> void forPossibleValue(Resource subject, AsyncProcedure<T> procedure);\r
 798     /**\r
 799      * @see ReadGraph#getPossibleValue(Resource)\r
 800      */\r
 801     <T> void forPossibleValue(Resource subject, SyncProcedure<T> procedure);\r
 802     /**\r
 803      * @see ReadGraph#getPossibleValue(Resource)\r
 804      */\r
 805     <T> void forPossibleValue(Resource subject, Procedure<T> procedure);\r
 806 \r
 807     /**\r
 808      * @see ReadGraph#getPossibleValue(Resource, Binding)\r
 809      */\r
 810     <T> void forPossibleValue(Resource subject, Binding binding, AsyncListener<T> procedure);\r
 811     /**\r
 812      * @see ReadGraph#getPossibleValue(Resource, Binding)\r
 813      */\r
 814     <T> void forPossibleValue(Resource subject, Binding binding, SyncListener<T> procedure);\r
 815     /**\r
 816      * @see ReadGraph#getPossibleValue(Resource, Binding)\r
 817      */\r
 818     <T> void forPossibleValue(Resource subject, Binding binding, Listener<T> procedure);\r
 819     /**\r
 820      * @see ReadGraph#getPossibleValue(Resource, Binding)\r
 821      */\r
 822     <T> void forPossibleValue(Resource subject, Binding binding, AsyncProcedure<T> procedure);\r
 823     /**\r
 824      * @see ReadGraph#getPossibleValue(Resource, Binding)\r
 825      */\r
 826     <T> void forPossibleValue(Resource subject, Binding binding, SyncProcedure<T> procedure);\r
 827     /**\r
 828      * @see ReadGraph#getPossibleValue(Resource, Binding)\r
 829      */\r
 830     <T> void forPossibleValue(Resource subject, Binding binding, Procedure<T> procedure);\r
 831 \r
 832     /**\r
 833      * @see ReadGraph#getPossibleRelatedValue(Resource, Resource)\r
 834      */\r
 835     <T> void forPossibleRelatedValue(Resource subject, Resource relation, AsyncListener<T> procedure);\r
 836     /**\r
 837      * @see ReadGraph#getPossibleRelatedValue(Resource, Resource)\r
 838      */\r
 839     <T> void forPossibleRelatedValue(Resource subject, Resource relation, SyncListener<T> procedure);\r
 840     /**\r
 841      * @see ReadGraph#getPossibleRelatedValue(Resource, Resource)\r
 842      */\r
 843     <T> void forPossibleRelatedValue(Resource subject, Resource relation, Listener<T> procedure);\r
 844     /**\r
 845      * @see ReadGraph#getPossibleRelatedValue(Resource, Resource)\r
 846      */\r
 847     <T> void forPossibleRelatedValue(Resource subject, Resource relation, AsyncProcedure<T> procedure);\r
 848     /**\r
 849      * @see ReadGraph#getPossibleRelatedValue(Resource, Resource)\r
 850      */\r
 851     <T> void forPossibleRelatedValue(Resource subject, Resource relation, SyncProcedure<T> procedure);\r
 852     /**\r
 853      * @see ReadGraph#getPossibleRelatedValue(Resource, Resource)\r
 854      */\r
 855     <T> void forPossibleRelatedValue(Resource subject, Resource relation, Procedure<T> procedure);\r
 856 \r
 857     /**\r
 858      * @see ReadGraph#getPossibleRelatedValue(Resource, Resource, Binding)\r
 859      */\r
 860     <T> void forPossibleRelatedValue(Resource subject, Resource relation, Binding binding, AsyncListener<T> procedure);\r
 861     /**\r
 862      * @see ReadGraph#getPossibleRelatedValue(Resource, Resource, Binding)\r
 863      */\r
 864     <T> void forPossibleRelatedValue(Resource subject, Resource relation, Binding binding, SyncListener<T> procedure);\r
 865     /**\r
 866      * @see ReadGraph#getPossibleRelatedValue(Resource, Resource, Binding)\r
 867      */\r
 868     <T> void forPossibleRelatedValue(Resource subject, Resource relation, Binding binding, Listener<T> procedure);\r
 869     /**\r
 870      * @see ReadGraph#getPossibleRelatedValue(Resource, Resource, Binding)\r
 871      */\r
 872     <T> void forPossibleRelatedValue(Resource subject, Resource relation, Binding binding, AsyncProcedure<T> procedure);\r
 873     /**\r
 874      * @see ReadGraph#getPossibleRelatedValue(Resource, Resource, Binding)\r
 875      */\r
 876     <T> void forPossibleRelatedValue(Resource subject, Resource relation, Binding binding, SyncProcedure<T> procedure);\r
 877     /**\r
 878      * @see ReadGraph#getPossibleRelatedValue(Resource, Resource, Binding)\r
 879      */\r
 880     <T> void forPossibleRelatedValue(Resource subject, Resource relation, Binding binding, Procedure<T> procedure);\r
 881 \r
 882     /**\r
 883      * @see ReadGraph#getPossibleAdapter(Resource, Class)\r
 884      */\r
 885     <T> void forPossibleAdapted(Resource resource, Class<T> clazz, AsyncListener<T> procedure);\r
 886     /**\r
 887      * @see ReadGraph#getPossibleAdapter(Resource, Class)\r
 888      */\r
 889     <T> void forPossibleAdapted(Resource resource, Class<T> clazz, SyncListener<T> procedure);\r
 890     /**\r
 891      * @see ReadGraph#getPossibleAdapter(Resource, Class)\r
 892      */\r
 893     <T> void forPossibleAdapted(Resource resource, Class<T> clazz, Listener<T> procedure);\r
 894     /**\r
 895      * @see ReadGraph#getPossibleAdapter(Resource, Class)\r
 896      */\r
 897     <T> void forPossibleAdapted(Resource resource, Class<T> clazz, AsyncProcedure<T> procedure);\r
 898     /**\r
 899      * @see ReadGraph#getPossibleAdapter(Resource, Class)\r
 900      */\r
 901     <T> void forPossibleAdapted(Resource resource, Class<T> clazz, SyncProcedure<T> procedure);\r
 902     /**\r
 903      * @see ReadGraph#getPossibleAdapter(Resource, Class)\r
 904      */\r
 905     <T> void forPossibleAdapted(Resource resource, Class<T> clazz, Procedure<T> procedure);\r
 906 \r
 907     /**\r
 908      * @see ReadGraph#getPossibleAdapter(Resource, Class)\r
 909      */\r
 910     <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz, AsyncListener<T> procedure);\r
 911     /**\r
 912      * @see ReadGraph#getPossibleAdapter(Resource, Class)\r
 913      */\r
 914     <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz, SyncListener<T> procedure);\r
 915     /**\r
 916      * @see ReadGraph#getPossibleAdapter(Resource, Class)\r
 917      */\r
 918     <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz, Listener<T> procedure);\r
 919     /**\r
 920      * @see ReadGraph#getPossibleAdapter(Resource, Class)\r
 921      */\r
 922     <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz, AsyncProcedure<T> procedure);\r
 923     /**\r
 924      * @see ReadGraph#getPossibleAdapter(Resource, Class)\r
 925      */\r
 926     <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz, SyncProcedure<T> procedure);\r
 927     /**\r
 928      * @see ReadGraph#getPossibleAdapter(Resource, Class)\r
 929      */\r
 930     <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz, Procedure<T> procedure);\r
 931 \r
 932     /**\r
 933      * @see ReadGraph#isInstanceOf(Resource, Resource)\r
 934      */\r
 935     void forIsInstanceOf(Resource resource, Resource type, AsyncListener<Boolean> procedure);\r
 936     /**\r
 937      * @see ReadGraph#isInstanceOf(Resource, Resource)\r
 938      */\r
 939     void forIsInstanceOf(Resource resource, Resource type, SyncListener<Boolean> procedure);\r
 940     /**\r
 941      * @see ReadGraph#isInstanceOf(Resource, Resource)\r
 942      */\r
 943     void forIsInstanceOf(Resource resource, Resource type, Listener<Boolean> procedure);\r
 944     /**\r
 945      * @see ReadGraph#isInstanceOf(Resource, Resource)\r
 946      */\r
 947     void forIsInstanceOf(Resource resource, Resource type, AsyncProcedure<Boolean> procedure);\r
 948     /**\r
 949      * @see ReadGraph#isInstanceOf(Resource, Resource)\r
 950      */\r
 951     void forIsInstanceOf(Resource resource, Resource type, SyncProcedure<Boolean> procedure);\r
 952     /**\r
 953      * @see ReadGraph#isInstanceOf(Resource, Resource)\r
 954      */\r
 955     void forIsInstanceOf(Resource resource, Resource type, Procedure<Boolean> procedure);\r
 956 \r
 957     /**\r
 958      * @see ReadGraph#isInheritedFrom(Resource, Resource)\r
 959      */\r
 960     void forIsInheritedFrom(Resource resource, Resource type, AsyncListener<Boolean> procedure);\r
 961     /**\r
 962      * @see ReadGraph#isInheritedFrom(Resource, Resource)\r
 963      */\r
 964     void forIsInheritedFrom(Resource resource, Resource type, SyncListener<Boolean> procedure);\r
 965     /**\r
 966      * @see ReadGraph#isInheritedFrom(Resource, Resource)\r
 967      */\r
 968     void forIsInheritedFrom(Resource resource, Resource type, Listener<Boolean> procedure);\r
 969     /**\r
 970      * @see ReadGraph#isInheritedFrom(Resource, Resource)\r
 971      */\r
 972     void forIsInheritedFrom(Resource resource, Resource type, AsyncProcedure<Boolean> procedure);\r
 973     /**\r
 974      * @see ReadGraph#isInheritedFrom(Resource, Resource)\r
 975      */\r
 976     void forIsInheritedFrom(Resource resource, Resource type, SyncProcedure<Boolean> procedure);\r
 977     /**\r
 978      * @see ReadGraph#isInheritedFrom(Resource, Resource)\r
 979      */\r
 980     void forIsInheritedFrom(Resource resource, Resource type, Procedure<Boolean> procedure);\r
 981 \r
 982     /**\r
 983      * @see ReadGraph#isSubrelationOf(Resource, Resource)\r
 984      */\r
 985     void forIsSubrelationOf(Resource resource, Resource relation, AsyncListener<Boolean> procedure);\r
 986     /**\r
 987      * @see ReadGraph#isSubrelationOf(Resource, Resource)\r
 988      */\r
 989     void forIsSubrelationOf(Resource resource, Resource relation, SyncListener<Boolean> procedure);\r
 990     /**\r
 991      * @see ReadGraph#isSubrelationOf(Resource, Resource)\r
 992      */\r
 993     void forIsSubrelationOf(Resource resource, Resource relation, Listener<Boolean> procedure);\r
 994     /**\r
 995      * @see ReadGraph#isSubrelationOf(Resource, Resource)\r
 996      */\r
 997     void forIsSubrelationOf(Resource resource, Resource relation, AsyncProcedure<Boolean> procedure);\r
 998     /**\r
 999      * @see ReadGraph#isSubrelationOf(Resource, Resource)\r
1000      */\r
1001     void forIsSubrelationOf(Resource resource, Resource relation, SyncProcedure<Boolean> procedure);\r
1002     /**\r
1003      * @see ReadGraph#isSubrelationOf(Resource, Resource)\r
1004      */\r
1005     void forIsSubrelationOf(Resource resource, Resource relation, Procedure<Boolean> procedure);\r
1006 \r
1007     /**\r
1008      * @see ReadGraph#hasStatement(Resource)\r
1009      */\r
1010     void forHasStatement(Resource subject, AsyncListener<Boolean> procedure);\r
1011     /**\r
1012      * @see ReadGraph#hasStatement(Resource)\r
1013      */\r
1014     void forHasStatement(Resource subject, SyncListener<Boolean> procedure);\r
1015     /**\r
1016      * @see ReadGraph#hasStatement(Resource)\r
1017      */\r
1018     void forHasStatement(Resource subject, Listener<Boolean> procedure);\r
1019     /**\r
1020      * @see ReadGraph#hasStatement(Resource)\r
1021      */\r
1022     void forHasStatement(Resource subject, AsyncProcedure<Boolean> procedure);\r
1023     /**\r
1024      * @see ReadGraph#hasStatement(Resource)\r
1025      */\r
1026     void forHasStatement(Resource subject, SyncProcedure<Boolean> procedure);\r
1027     /**\r
1028      * @see ReadGraph#hasStatement(Resource)\r
1029      */\r
1030     void forHasStatement(Resource subject, Procedure<Boolean> procedure);\r
1031 \r
1032     /**\r
1033      * @see ReadGraph#hasStatement(Resource, Resource)\r
1034      */\r
1035     void forHasStatement(Resource subject, Resource relation, AsyncListener<Boolean> procedure);\r
1036     /**\r
1037      * @see ReadGraph#hasStatement(Resource, Resource)\r
1038      */\r
1039     void forHasStatement(Resource subject, Resource relation, SyncListener<Boolean> procedure);\r
1040     /**\r
1041      * @see ReadGraph#hasStatement(Resource, Resource)\r
1042      */\r
1043     void forHasStatement(Resource subject, Resource relation, Listener<Boolean> procedure);\r
1044     /**\r
1045      * @see ReadGraph#hasStatement(Resource, Resource)\r
1046      */\r
1047     void forHasStatement(Resource subject, Resource relation, AsyncProcedure<Boolean> procedure);\r
1048     /**\r
1049      * @see ReadGraph#hasStatement(Resource, Resource)\r
1050      */\r
1051     void forHasStatement(Resource subject, Resource relation, SyncProcedure<Boolean> procedure);\r
1052     /**\r
1053      * @see ReadGraph#hasStatement(Resource, Resource)\r
1054      */\r
1055     void forHasStatement(Resource subject, Resource relation, Procedure<Boolean> procedure);\r
1056 \r
1057     /**\r
1058      * @see ReadGraph#hasStatement(Resource, Resource, Resource)\r
1059      */\r
1060     void forHasStatement(Resource subject, Resource relation, Resource object, AsyncListener<Boolean> procedure);\r
1061     /**\r
1062      * @see ReadGraph#hasStatement(Resource, Resource, Resource)\r
1063      */\r
1064     void forHasStatement(Resource subject, Resource relation, Resource object, SyncListener<Boolean> procedure);\r
1065     /**\r
1066      * @see ReadGraph#hasStatement(Resource, Resource, Resource)\r
1067      */\r
1068     void forHasStatement(Resource subject, Resource relation, Resource object, Listener<Boolean> procedure);\r
1069     /**\r
1070      * @see ReadGraph#hasStatement(Resource, Resource, Resource)\r
1071      */\r
1072     void forHasStatement(Resource subject, Resource relation, Resource object, AsyncProcedure<Boolean> procedure);\r
1073     /**\r
1074      * @see ReadGraph#hasStatement(Resource, Resource, Resource)\r
1075      */\r
1076     void forHasStatement(Resource subject, Resource relation, Resource object, SyncProcedure<Boolean> procedure);\r
1077     /**\r
1078      * @see ReadGraph#hasStatement(Resource, Resource, Resource)\r
1079      */\r
1080     void forHasStatement(Resource subject, Resource relation, Resource object, Procedure<Boolean> procedure);\r
1081 \r
1082     /**\r
1083      * @see ReadGraph#hasValue(Resource)\r
1084      */\r
1085     void forHasValue(Resource subject, AsyncListener<Boolean> procedure);\r
1086     /**\r
1087      * @see ReadGraph#hasValue(Resource)\r
1088      */\r
1089     void forHasValue(Resource subject, SyncListener<Boolean> procedure);\r
1090     /**\r
1091      * @see ReadGraph#hasValue(Resource)\r
1092      */\r
1093     void forHasValue(Resource subject, Listener<Boolean> procedure);\r
1094     /**\r
1095      * @see ReadGraph#hasValue(Resource)\r
1096      */\r
1097     void forHasValue(Resource subject, AsyncProcedure<Boolean> procedure);\r
1098     /**\r
1099      * @see ReadGraph#hasValue(Resource)\r
1100      */\r
1101     void forHasValue(Resource subject, SyncProcedure<Boolean> procedure);\r
1102     /**\r
1103      * @see ReadGraph#hasValue(Resource)\r
1104      */\r
1105     void forHasValue(Resource subject, Procedure<Boolean> procedure);\r
1106 \r
1107     /**\r
1108      * @see ReadGraph#getTypes(Resource)\r
1109      */\r
1110     void forOrderedSet(Resource subject, AsyncMultiListener<Resource> procedure);\r
1111     /**\r
1112      * @see ReadGraph#getTypes(Resource)\r
1113      */\r
1114     void forOrderedSet(Resource subject, SyncMultiListener<Resource> procedure);\r
1115     /**\r
1116      * @see ReadGraph#getTypes(Resource)\r
1117      */\r
1118     void forOrderedSet(Resource subject, MultiListener<Resource> procedure);\r
1119     /**\r
1120      * @see ReadGraph#getTypes(Resource)\r
1121      */\r
1122     void forOrderedSet(Resource subject, AsyncMultiProcedure<Resource> procedure);\r
1123     /**\r
1124      * @see ReadGraph#getTypes(Resource)\r
1125      */\r
1126     void forOrderedSet(Resource subject, SyncMultiProcedure<Resource> procedure);\r
1127     /**\r
1128      * @see ReadGraph#getTypes(Resource)\r
1129      */\r
1130     void forOrderedSet(Resource subject, MultiProcedure<Resource> procedure);\r
1131 \r
1132     int thread();\r
1133 //    void inc();\r
1134 //    void dec();\r
1135     \r
1136     boolean isImmutable(Resource resource) throws DatabaseException;\r
1137     \r
1138 }\r