package org.simantics.interop.mapping;

import java.util.Collection;
import java.util.Set;
import java.util.TreeMap;

import org.simantics.databoard.accessor.Accessor;
import org.simantics.databoard.binding.Binding;
import org.simantics.databoard.type.Datatype;
import org.simantics.databoard.util.binary.RandomAccessBinary;
import org.simantics.db.Metadata;
import org.simantics.db.Resource;
import org.simantics.db.Session;
import org.simantics.db.Statement;
import org.simantics.db.VirtualGraph;
import org.simantics.db.WriteGraph;
import org.simantics.db.exception.AdaptionException;
import org.simantics.db.exception.AssumptionException;
import org.simantics.db.exception.BindingException;
import org.simantics.db.exception.DatabaseException;
import org.simantics.db.exception.DoesNotContainValueException;
import org.simantics.db.exception.ManyObjectsForFunctionalRelationException;
import org.simantics.db.exception.NoInverseException;
import org.simantics.db.exception.NoSingleResultException;
import org.simantics.db.exception.ResourceNotFoundException;
import org.simantics.db.exception.ServiceException;
import org.simantics.db.exception.ServiceNotFoundException;
import org.simantics.db.exception.ValidationException;
import org.simantics.db.procedure.AsyncListener;
import org.simantics.db.procedure.AsyncMultiListener;
import org.simantics.db.procedure.AsyncMultiProcedure;
import org.simantics.db.procedure.AsyncProcedure;
import org.simantics.db.procedure.AsyncSetListener;
import org.simantics.db.procedure.Listener;
import org.simantics.db.procedure.MultiListener;
import org.simantics.db.procedure.MultiProcedure;
import org.simantics.db.procedure.Procedure;
import org.simantics.db.procedure.SetListener;
import org.simantics.db.procedure.SyncListener;
import org.simantics.db.procedure.SyncMultiListener;
import org.simantics.db.procedure.SyncMultiProcedure;
import org.simantics.db.procedure.SyncProcedure;
import org.simantics.db.procedure.SyncSetListener;
import org.simantics.db.request.AsyncMultiRead;
import org.simantics.db.request.AsyncRead;
import org.simantics.db.request.DelayedWrite;
import org.simantics.db.request.DelayedWriteResult;
import org.simantics.db.request.ExternalRead;
import org.simantics.db.request.MultiRead;
import org.simantics.db.request.Read;
import org.simantics.db.request.ReadInterface;
import org.simantics.db.request.Write;
import org.simantics.db.request.WriteInterface;
import org.simantics.db.request.WriteOnly;
import org.simantics.db.request.WriteOnlyResult;
import org.simantics.db.request.WriteResult;
import org.simantics.db.request.WriteTraits;
import org.simantics.scl.types.Type;
import org.simantics.utils.datastructures.Callback;

/**
 * 
 * @author Marko Luukkainen <marko.luukkainen@vtt.fi>
 *
 */
public class WriteGraphProxy implements WriteGraph {
	
	protected WriteGraph graph;
	
	
	@Override
	public <T> T getRelatedValue2(Resource subject, Resource relation)
			throws DatabaseException {
		return graph.getRelatedValue2(subject, relation);
	}
	
	@Override
	public <T> T getRelatedValue2(Resource subject, Resource relation,
			Binding binding) throws DatabaseException {
		return graph.getRelatedValue2(subject, relation, binding);
	}
	
	@Override
	public <T> T getRelatedValue2(Resource subject, Resource relation,
			Object context) throws DatabaseException {
		return graph.getRelatedValue2(subject, relation, context);
	}
	
	@Override
	public <T> T getRelatedValue2(Resource subject, Resource relation,
			Object context, Binding binding) throws DatabaseException {
		return graph.getRelatedValue2(subject, relation, context, binding);
	}
	
	@Override
	public <T> T getPossibleRelatedValue2(Resource subject, Resource relation)
			throws DatabaseException {
		return graph.getPossibleRelatedValue2(subject, relation);
	}
	
	@Override
	public <T> T getPossibleRelatedValue2(Resource subject, Resource relation,
			Binding binding) throws DatabaseException {
		return graph.getPossibleRelatedValue2(subject, relation, binding);
	}
	
	@Override
	public <T> T getPossibleRelatedValue2(Resource subject, Resource relation,
			Object context) throws DatabaseException {
		return graph.getPossibleRelatedValue2(subject, relation, context);
	}
	
	@Override
	public <T> T getPossibleRelatedValue2(Resource subject, Resource relation,
			Object context, Binding binding) throws DatabaseException {
		return getPossibleRelatedValue2(subject, relation, context, binding);
	}
	
	@Override
	public <T> void async(ReadInterface<T> r, AsyncListener<T> procedure) {
		graph.async(r,procedure);
	}
	
	@Override
	public <T> void async(ReadInterface<T> r, AsyncProcedure<T> procedure) {
		graph.async(r, procedure);
	}
	
	@Override
	public <T> void async(ReadInterface<T> r, Listener<T> procedure) {
		graph.async(r, procedure);
	}
	
	@Override
	public <T> void async(ReadInterface<T> r, Procedure<T> procedure) {
		graph.async(r, procedure);
	}
	
	@Override
	public <T> void async(ReadInterface<T> r, SyncListener<T> procedure) {
		graph.async(r, procedure);
	}
	
	@Override
	public <T> void async(ReadInterface<T> r, SyncProcedure<T> procedure) {
		graph.async(r, procedure);
	}
	
	@Override
	public <T> void async(WriteInterface<T> r) {
		graph.async(r);
	}
	
	@Override
	public <T> void async(WriteInterface<T> r, Procedure<T> procedure) {
		graph.async(r, procedure);
	}
	
	@Override
	public <T> T sync(ReadInterface<T> r) throws DatabaseException {
		return graph.sync(r);
	}
	
	@Override
	public <T> T sync(WriteInterface<T> r) throws DatabaseException {
		return graph.sync(r);
	}
	
	@Override
	public Resource getRootLibrary() {
		return graph.getRootLibrary();
	}
	
	
	@Override
	public void clearUndoList(WriteTraits writeTraits) {
		graph.clearUndoList(writeTraits);
	}
	
	@Override
	public void combineWithPrevious(WriteTraits writeTraits) {
		graph.combineWithPrevious(writeTraits);
	}
	
	@Override
	public TreeMap<String, byte[]> getMetadata() {
		return graph.getMetadata();
	}
	
	@Override
	public <T extends Metadata> T getMetadata(Class<T> clazz)
			throws ServiceException {
		return graph.getMetadata(clazz);
	}
	
	@Override
	public Type getRelatedValueType(Resource subject, Resource relation)
			throws DatabaseException {
		return graph.getRelatedValueType(subject, relation);
	}
	
	@Override
	public void deny(Resource subject, Resource predicate, Resource inverse,
			Resource object, VirtualGraph graph) throws ServiceException {
		this.graph.deny(subject, predicate, inverse, object, graph);
	}
	
	
	
	
	@Override
	public <T> T adaptRelated(Resource resource, Resource relation,
			Class<T> clazz) throws AdaptionException, NoSingleResultException,
			ValidationException, ServiceException {
		return graph.adaptRelated(resource, relation, clazz);
	}
	
	@Override
	public <T> T getPossibleRelatedAdapter(Resource resource,
			Resource relation, Class<T> clazz) throws ValidationException,
			ServiceException {
		return graph.getPossibleRelatedAdapter(resource, relation, clazz);
	}
	
	@Override
	public void inc() {
		graph.inc();
	}
	
	@Override
	public void dec() {
		graph.dec();
	}
	
	@Override
	public Collection<Resource> getObjects(Resource subject, Resource relation) throws ServiceException 
			{
		return graph.getObjects(subject, relation);
	}
	
	@Override
	public <T extends Accessor> T newLiteral(Resource resource,
	Resource predicate, Datatype datatype, Object initialValue)
	throws DatabaseException {
		return graph.newLiteral(resource, predicate, datatype, initialValue);
	}

	@Override
	public RandomAccessBinary createRandomAccessBinary(Resource resource,
			Resource predicate, Datatype datatype, Object initialValue)
			throws DatabaseException {
		return graph.createRandomAccessBinary(resource, predicate, datatype, initialValue);
	}
	
	@Override
	public RandomAccessBinary createRandomAccessBinary(Resource resource,
			Datatype datatype, Object initialValue) throws DatabaseException {
		return graph.createRandomAccessBinary(resource, datatype, initialValue);
	}
	
//	@Override
//	public void claimFile(Resource resource, Object content, Binding binding)
//			throws DatabaseException {
//		graph.claimFile(resource, content, binding);
//	}
//	
//	@Override
//	public void denyFile(Resource resource) throws DatabaseException {
//		graph.denyFile(resource);
//	}
	
	public <T, C> T adaptContextual(Resource resource, C context, java.lang.Class<C> contextClass, java.lang.Class<T> clazz) throws AdaptionException ,NoSingleResultException ,ValidationException ,ServiceException {
		return graph.adaptContextual(resource, context, contextClass, clazz);
	};
	
	public <T, C> T getPossibleContextualAdapter(Resource resource, C context, java.lang.Class<C> contextClass, java.lang.Class<T> clazz) throws ValidationException ,ServiceException {
		return graph.getPossibleContextualAdapter(resource, context, contextClass, clazz);
	};
	
	
	public WriteGraphProxy(WriteGraph graph) {
		this.graph = graph;
	}
	
	@Override
	public Resource newResource() throws ServiceException {
		return graph.newResource();
	}
	
	@Override
	public Resource newResource(long clusterId) throws ServiceException {
		return graph.newResource(clusterId);
	}
	
	@Override
	public <T> T adapt(Resource resource, Class<T> clazz)
			throws AdaptionException, ValidationException, ServiceException {
		return graph.adapt(resource, clazz);
	}
	
	@Override
	public <T> T adaptUnique(Resource resource, Class<T> clazz)
			throws AdaptionException, ValidationException, ServiceException {
		return adaptUnique(resource, clazz);
	}
	
	@Override
	public void addLiteral(Resource resource, Resource predicate,
			Resource inverse, Object value, Binding binding)
			throws BindingException,
			ManyObjectsForFunctionalRelationException, ServiceException {
		graph.addLiteral(resource, predicate, inverse, value, binding);
	}
	
	@Override
	public void addLiteral(Resource resource, Resource predicate,
			Resource inverse, Resource type, Object value, Binding binding)
			throws BindingException,
			ManyObjectsForFunctionalRelationException, ServiceException {
		graph.addLiteral(resource, predicate, inverse, type, value, binding);
	}
	
	@Override
	public <T> void addMetadata(Metadata data) throws ServiceException {
		graph.addMetadata(data);
	}
	
	@SuppressWarnings("deprecation")
	@Override
	public void addValue(Resource resource, Resource predicate,
			Resource inverse, Resource type, Object value, Binding binding)
			throws BindingException,
			ManyObjectsForFunctionalRelationException, ServiceException {
		graph.addValue(resource, predicate, inverse, type, value, binding);
	}
	
	@Override
	public <T> void asyncRequest(AsyncMultiRead<T> request) {
		graph.asyncRequest(request);
	}
	
	@Override
	public <T> void asyncRequest(AsyncMultiRead<T> request,
			AsyncMultiListener<T> procedure) {
		graph.asyncRequest(request,procedure);
	}
	
	@Override
	public <T> void asyncRequest(AsyncMultiRead<T> request,
			AsyncMultiProcedure<T> procedure) {
		graph.asyncRequest(request,procedure);
	}
	
	@Override
	public <T> void asyncRequest(AsyncMultiRead<T> request,
			MultiListener<T> procedure) {
		graph.asyncRequest(request,procedure);
	}
	
	@Override
	public <T> void asyncRequest(AsyncMultiRead<T> request,
			MultiProcedure<T> procedure) {
		graph.asyncRequest(request,procedure);
	}
	
	@Override
	public <T> void asyncRequest(AsyncMultiRead<T> request,
			SyncMultiListener<T> procedure) {
		graph.asyncRequest(request,procedure);
	}
	
	@Override
	public <T> void asyncRequest(AsyncMultiRead<T> request,
			SyncMultiProcedure<T> procedure) {
		graph.asyncRequest(request,procedure);	
	}
	
	@Override
	public <T> void asyncRequest(AsyncRead<T> request) {
		graph.asyncRequest(request);	
	}
	
	@Override
	public <T> void asyncRequest(AsyncRead<T> request,
			AsyncListener<T> procedure) {
		graph.asyncRequest(request,procedure);	
	}
	
	@Override
	public <T> void asyncRequest(AsyncRead<T> request,
			AsyncProcedure<T> procedure) {
		graph.asyncRequest(request,procedure);	
	}
	
	@Override
	public <T> void asyncRequest(AsyncRead<T> request, Listener<T> procedure) {
		graph.asyncRequest(request,procedure);	
	}
	
	@Override
	public <T> void asyncRequest(AsyncRead<T> request,
			Procedure<T> procedure) {
		graph.asyncRequest(request,procedure);	
	}
	
	@Override
	public <T> void asyncRequest(AsyncRead<T> request,
			SyncListener<T> procedure) {
		graph.asyncRequest(request,procedure);	
	}
	
	@Override
	public <T> void asyncRequest(AsyncRead<T> request,
			SyncProcedure<T> procedure) {
		graph.asyncRequest(request,procedure);	
	}
	
	@Override
	public void asyncRequest(DelayedWrite request) {
		graph.asyncRequest(request);	
	}
	
	@Override
	public void asyncRequest(DelayedWrite request,
			Callback<DatabaseException> callback) {
		graph.asyncRequest(request,callback);	
	}
	
	@Override
	public <T> void asyncRequest(DelayedWriteResult<T> r,
			Procedure<T> procedure) {
		graph.asyncRequest(r,procedure);	
	}
	
	@Override
	public <T> void asyncRequest(ExternalRead<T> request) {
		graph.asyncRequest(request);	
	}
	
	@Override
	public <T> void asyncRequest(ExternalRead<T> request,
			Listener<T> procedure) {
		graph.asyncRequest(request,procedure);
	}	
	
	@Override
	public <T> void asyncRequest(ExternalRead<T> request,
			Procedure<T> procedure) {
		graph.asyncRequest(request,procedure);
	}
	
	@Override
	public <T> void asyncRequest(MultiRead<T> request) {
		graph.asyncRequest(request);	
	}
	
	@Override
	public <T> void asyncRequest(MultiRead<T> request,
			AsyncMultiListener<T> procedure) {
		graph.asyncRequest(request,procedure);	
	}
	
	@Override
	public <T> void asyncRequest(MultiRead<T> request,
			AsyncMultiProcedure<T> procedure) {
		graph.asyncRequest(request,procedure);	
	}
	
	@Override
	public <T> void asyncRequest(MultiRead<T> request,
			MultiListener<T> procedure) {
		graph.asyncRequest(request,procedure);	
	}
	
	@Override
	public <T> void asyncRequest(MultiRead<T> request,
			MultiProcedure<T> procedure) {
		graph.asyncRequest(request,procedure);	
	}
	
	@Override
	public <T> void asyncRequest(MultiRead<T> request,
			SyncMultiListener<T> procedure) {
		graph.asyncRequest(request,procedure);	
	}
	
	@Override
	public <T> void asyncRequest(MultiRead<T> request,
			SyncMultiProcedure<T> procedure) {
		graph.asyncRequest(request,procedure);	
	}
	
	@Override
	public <T> void asyncRequest(Read<T> request) {
		graph.asyncRequest(request);	
	}
	
	@Override
	public <T> void asyncRequest(Read<T> request, AsyncListener<T> procedure) {
		graph.asyncRequest(request,procedure);	
	}
	
	@Override
	public <T> void asyncRequest(Read<T> request,
			AsyncProcedure<T> procedure) {
		graph.asyncRequest(request,procedure);	
	}
	
	@Override
	public <T> void asyncRequest(Read<T> request, Listener<T> procedure) {
		graph.asyncRequest(request,procedure);	
	}
	
	@Override
	public <T> void asyncRequest(Read<T> request, Procedure<T> procedure) {
		graph.asyncRequest(request,procedure);	
	}
	
	@Override
	public <T> void asyncRequest(Read<T> request, SyncListener<T> procedure) {
		graph.asyncRequest(request,procedure);	
	}
	
	@Override
	public <T> void asyncRequest(Read<T> request, SyncProcedure<T> procedure) {
		graph.asyncRequest(request,procedure);	
	}
	
	@Override
	public void asyncRequest(Write request) {
		graph.asyncRequest(request);	
	}
	
	@Override
	public void asyncRequest(Write request,
			Callback<DatabaseException> callback) {
		graph.asyncRequest(request, callback);	
	}
	
	@Override
	public void asyncRequest(WriteOnly r) {
		graph.asyncRequest(r);	
	}
	
	@Override
	public void asyncRequest(WriteOnly r,
			Callback<DatabaseException> callback) {
		graph.asyncRequest(r,callback);	
	}
	
	@Override
	public <T> void asyncRequest(WriteOnlyResult<T> r,
			Procedure<T> procedure) {
		graph.asyncRequest(r,procedure);	
	}
	
	@Override
	public <T> void asyncRequest(WriteResult<T> r, Procedure<T> procedure) {
		graph.asyncRequest(r,procedure);	
	}
	
	
	
	@Override
	public void claim(Resource subject, Resource predicate,
			Resource inverse, Resource object) throws ServiceException {
		graph.claim(subject, predicate, inverse, object);
	}
	
	@Override
	public void claim(Resource subject, Resource predicate, Resource object)
			throws ServiceException {
		graph.claim(subject, predicate, object);
	}
	

	@Override
	public void claimLiteral(Resource resource, Resource predicate,
			Object value) throws ManyObjectsForFunctionalRelationException,
			ServiceException {
		graph.claimLiteral(resource, predicate, value);
	}
	
	@Override
	public void claimLiteral(Resource resource, Resource predicate,
			Object value, Binding binding) throws BindingException,
			ManyObjectsForFunctionalRelationException, ServiceException {
		graph.claimLiteral(resource, predicate, value, binding);
	}
	
	@Override
	public void claimLiteral(Resource resource, Resource predicate,
			Resource inverse, Resource type, Object value)
			throws BindingException,
			ManyObjectsForFunctionalRelationException, ServiceException {
		graph.claimLiteral(resource, predicate, inverse, type, value);
	}
	
	@Override
	public void claimLiteral(Resource resource, Resource predicate,
			Resource inverse, Resource type, Object value, Binding binding)
			throws BindingException,
			ManyObjectsForFunctionalRelationException, ServiceException {
		graph.claimLiteral(resource, predicate, inverse, type, value, binding);
	}
	
	@Override
	public void claimLiteral(Resource resource, Resource predicate,
			Resource type, Object value) throws BindingException,
			ManyObjectsForFunctionalRelationException, ServiceException {
		graph.claimLiteral(resource, predicate, type, value);
	}
	
	@Override
	public void claimLiteral(Resource resource, Resource predicate,
			Resource type, Object value, Binding binding)
			throws BindingException,
			ManyObjectsForFunctionalRelationException, ServiceException {
		graph.claimLiteral(resource, predicate, type, value, binding);
	}
	
	@Override
	public void claimValue(Resource resource, Object value)
			throws ServiceException {
		graph.claimValue(resource, value);
	}
	
	@Override
	public void claimValue(Resource resource, Object value, Binding binding)
			throws ServiceException {
		graph.claimValue(resource, value, binding);	
	}
	
	@SuppressWarnings("deprecation")
	@Override
	public void claimValue(Resource resource, Resource predicate,
			Object value) throws ManyObjectsForFunctionalRelationException,
			ServiceException {
		graph.claimValue(resource, predicate, value);	
	}
	
	@SuppressWarnings("deprecation")
	@Override
	public void claimValue(Resource resource, Resource predicate,
			Object value, Binding binding) throws BindingException,
			ManyObjectsForFunctionalRelationException, ServiceException {
		graph.claimValue(resource, predicate, value, binding);
	}
	
	@SuppressWarnings("deprecation")
	@Override
	public void claimValue(Resource resource, Resource predicate,
			Resource inverse, Resource type, Object value, Binding binding)
			throws BindingException,
			ManyObjectsForFunctionalRelationException, ServiceException {
		graph.claimValue(resource, predicate, inverse, type, value, binding);
	}
	
	@Override
	public void deny(Resource subject) throws ServiceException {
		graph.deny(subject);
	}
	
	@Override
	public void deny(Resource subject, Resource predicate)
			throws ServiceException {
		graph.deny(subject, predicate);
	}
	
	@Override
	public void deny(Resource subject, Resource predicate,
			Resource inverse, Resource object) throws ServiceException {
		graph.deny(subject, predicate, inverse, object);
	}
	
	@Override
	public void deny(Resource subject, Resource predicate, Resource object)
			throws ServiceException {
		graph.deny(subject, predicate, object);
	}
	
	@Override
	public void deny(Statement statement) throws ServiceException {
		graph.deny(statement);
	}
	

	@Override
	public void denyStatement(Resource subject, Resource predicate,
			Resource object) throws ServiceException {
		graph.denyStatement(subject, predicate, object);
	}
	
	@Override
	public void denyValue(Resource resource) throws ServiceException {
		graph.denyValue(resource);
	}
	
	@Override
	public void denyValue(Resource resource, Resource predicate)
			throws ManyObjectsForFunctionalRelationException,
			ServiceException {
		graph.denyValue(resource, predicate);
	}
	
	@Override
	public void flushCluster() throws ServiceException {
		graph.flushCluster();
	}
	
	@Override
	public void flushCluster(Resource r) throws ServiceException {
		graph.flushCluster(r);
	}
	
	@Override
	public <T> void forAdapted(Resource resource, Class<T> clazz,
			AsyncListener<T> procedure) {
		graph.forAdapted(resource, clazz, procedure);
	}
	
	@Override
	public <T> void forAdapted(Resource resource, Class<T> clazz,
			AsyncProcedure<T> procedure) {
		graph.forAdapted(resource, clazz, procedure);
	}
	
	@Override
	public <T> void forAdapted(Resource resource, Class<T> clazz,
			Listener<T> procedure) {
		graph.forAdapted(resource, clazz, procedure);
	}
	
	@Override
	public <T> void forAdapted(Resource resource, Class<T> clazz,
			Procedure<T> procedure) {
		graph.forAdapted(resource, clazz, procedure);
	}
	
	@Override
	public <T> void forAdapted(Resource resource, Class<T> clazz,
			SyncListener<T> procedure) {
		graph.forAdapted(resource, clazz, procedure);
	}
	
	@Override
	public <T> void forAdapted(Resource resource, Class<T> clazz,
			SyncProcedure<T> procedure) {
		graph.forAdapted(resource, clazz, procedure);
	}
	
	@Override
	public void forAssertedObjectSet(Resource subject, Resource relation,
			AsyncSetListener<Resource> procedure) {
		graph.forAssertedObjectSet(subject, relation, procedure);
	}
	
	@Override
	public void forAssertedObjectSet(Resource subject, Resource relation,
			SetListener<Resource> procedure) {
		graph.forAssertedObjectSet(subject, relation, procedure);
	}
	
	@Override
	public void forAssertedObjectSet(Resource subject, Resource relation,
			SyncSetListener<Resource> procedure) {
		graph.forAssertedObjectSet(subject, relation, procedure);
	}
	
	@Override
	public void forAssertedStatementSet(Resource subject,
			Resource relation, AsyncSetListener<Statement> procedure) {
		graph.forAssertedStatementSet(subject, relation, procedure);
	}
	
	@Override
	public void forAssertedStatementSet(Resource subject,
			Resource relation, SetListener<Statement> procedure) {
		graph.forAssertedStatementSet(subject, relation, procedure);
	}
	
	@Override
	public void forAssertedStatementSet(Resource subject,
			Resource relation, SyncSetListener<Statement> procedure) {
		graph.forAssertedStatementSet(subject, relation, procedure);
	}
	
	@Override
	public void forBuiltin(String id, AsyncListener<Resource> procedure) {
		graph.forBuiltin(id, procedure);
	}
	
	@Override
	public void forBuiltin(String id, Listener<Resource> procedure) {
		graph.forBuiltin(id, procedure);
	}
	
	@Override
	public void forBuiltin(String id, AsyncProcedure<Resource> procedure) {
		graph.forBuiltin(id, procedure);
	}
	
	@Override
	public void forBuiltin(String id, Procedure<Resource> procedure) {
		graph.forBuiltin(id, procedure);
	}
	
	@Override
	public void forBuiltin(String id, SyncListener<Resource> procedure) {
		graph.forBuiltin(id, procedure);
	}
	
	@Override
	public void forBuiltin(String id, SyncProcedure<Resource> procedure) {
		graph.forBuiltin(id, procedure);
	}
	
	@Override
	public void forDirectSuperrelations(Resource subject,
			AsyncMultiProcedure<Resource> procedure) {
		graph.forDirectSuperrelations(subject, procedure);
	}
	
	@Override
	public void forEachAssertedObject(Resource subject, Resource relation,
			AsyncMultiProcedure<Resource> procedure) {
		graph.forEachAssertedObject(subject, relation, procedure);
	}
	
	@Override
	public void forEachAssertedObject(Resource subject, Resource relation,
			MultiProcedure<Resource> procedure) {
		graph.forEachAssertedObject(subject, relation, procedure);	
	}
	
	@Override
	public void forEachAssertedObject(Resource subject, Resource relation,
			SyncMultiProcedure<Resource> procedure) {
		graph.forEachAssertedObject(subject, relation, procedure);	
	}
	
	@Override
	public void forEachAssertedStatement(Resource subject,
			Resource relation, AsyncMultiProcedure<Statement> procedure) {
		graph.forEachAssertedStatement(subject, relation, procedure);
	}
	
	@Override
	public void forEachAssertedStatement(Resource subject,
			Resource relation, MultiProcedure<Statement> procedure) {
		graph.forEachAssertedStatement(subject, relation, procedure);
	}
	
	@Override
	public void forEachAssertedStatement(Resource subject,
			Resource relation, SyncMultiProcedure<Statement> procedure) {
		graph.forEachAssertedStatement(subject, relation, procedure);
	}
	
//	@Override
//	public void forEachDirectObject(Resource subject, Resource relation,
//			AsyncMultiProcedure<Resource> procedure) {
//		graph.forEachDirectObject(subject, relation, procedure);
//	}
//	
//	@Override
//	public void forEachDirectObject(Resource subject, Resource relation,
//			MultiProcedure<Resource> procedure) {
//		graph.forEachDirectObject(subject, relation, procedure);
//	}
//	
//	@Override
//	public void forEachDirectObject(Resource subject, Resource relation,
//			SyncMultiProcedure<Resource> procedure) {
//		graph.forEachDirectObject(subject, relation, procedure);
//	}
	
	@Override
	public void forEachDirectPredicate(Resource subject,
			AsyncMultiProcedure<Resource> procedure) {
		graph.forEachDirectPredicate(subject, procedure);
	}
	
	@Override
	public void forEachDirectPredicate(Resource subject,
			MultiProcedure<Resource> procedure) {
		graph.forEachDirectPredicate(subject, procedure);
	}
	
	@Override
	public void forEachDirectPredicate(Resource subject,
			SyncMultiProcedure<Resource> procedure) {
		graph.forEachDirectPredicate(subject, procedure);
	}
	
	@Override
	public void forEachObject(Resource subject, Resource relation,
			AsyncMultiProcedure<Resource> procedure) {
		graph.forEachObject(subject, relation, procedure);
	}
	
	@Override
	public void forEachObject(Resource subject, Resource relation,
			MultiProcedure<Resource> procedure) {
		graph.forEachObject(subject, relation, procedure);
	}
	
	@Override
	public void forEachObject(Resource subject, Resource relation,
			SyncMultiProcedure<Resource> procedure) {
		graph.forEachObject(subject, relation, procedure);
	}
	
	@Override
	public void forEachPredicate(Resource subject,
			AsyncMultiProcedure<Resource> procedure) {
		graph.forEachPredicate(subject, procedure);
	}
	
	@Override
	public void forEachPredicate(Resource subject,
			MultiProcedure<Resource> procedure) {
		graph.forEachPredicate(subject, procedure);
	}
	
	@Override
	public void forEachPredicate(Resource subject,
			SyncMultiProcedure<Resource> procedure) {
		graph.forEachPredicate(subject, procedure);
	}
	
	@Override
	public void forEachPrincipalType(Resource subject,
			AsyncMultiProcedure<Resource> procedure) {
		graph.forEachPrincipalType(subject, procedure);
	}
	
	@Override
	public void forEachPrincipalType(Resource subject,
			MultiProcedure<Resource> procedure) {
		graph.forEachPrincipalType(subject, procedure);
	}
	
	@Override
	public void forEachPrincipalType(Resource subject,
			SyncMultiProcedure<Resource> procedure) {
		graph.forEachPrincipalType(subject, procedure);
	}
	
	@Override
	public void forEachStatement(Resource subject, Resource relation,
			AsyncMultiProcedure<Statement> procedure) {
		graph.forEachStatement(subject, relation, procedure);
	}
	
	@Override
	public void forEachStatement(Resource subject, Resource relation,
			MultiProcedure<Statement> procedure) {
		graph.forEachStatement(subject, relation, procedure);
	}
	
	@Override
	public void forEachStatement(Resource subject, Resource relation,
			SyncMultiProcedure<Statement> procedure) {
		graph.forEachStatement(subject, relation, procedure);
	}
	
	@Override
	public void forHasStatement(Resource subject,
			AsyncListener<Boolean> procedure) {
		graph.forHasStatement(subject, procedure);
	}
	
	@Override
	public void forHasStatement(Resource subject,
			AsyncProcedure<Boolean> procedure) {
		graph.forHasStatement(subject, procedure);	
	}
	
	@Override
	public void forHasStatement(Resource subject,
			Listener<Boolean> procedure) {
		graph.forHasStatement(subject, procedure);	
	}
	
	@Override
	public void forHasStatement(Resource subject,
			Procedure<Boolean> procedure) {
		graph.forHasStatement(subject, procedure);
	}
	
	@Override
	public void forHasStatement(Resource subject, Resource relation,
			AsyncListener<Boolean> procedure) {
		graph.forHasStatement(subject, relation, procedure);	
	}
	
	@Override
	public void forHasStatement(Resource subject, Resource relation,
			AsyncProcedure<Boolean> procedure) {
		graph.forHasStatement(subject, relation, procedure);
	}
	
	@Override
	public void forHasStatement(Resource subject, Resource relation,
			Listener<Boolean> procedure) {
		graph.forHasStatement(subject, relation, procedure);
	}
	
	@Override
	public void forHasStatement(Resource subject, Resource relation,
			Procedure<Boolean> procedure) {
		graph.forHasStatement(subject, relation, procedure);	
	}
	
	@Override
	public void forHasStatement(Resource subject, Resource relation,
			Resource object, AsyncListener<Boolean> procedure) {
		graph.forHasStatement(subject, relation, object, procedure);
	}
	
	@Override
	public void forHasStatement(Resource subject, Resource relation,
			Resource object, AsyncProcedure<Boolean> procedure) {
		graph.forHasStatement(subject, relation, object, procedure);	
	}
	
	@Override
	public void forHasStatement(Resource subject, Resource relation,
			Resource object, Listener<Boolean> procedure) {
		graph.forHasStatement(subject, relation, object, procedure);	
	}
	
	@Override
	public void forHasStatement(Resource subject, Resource relation,
			Resource object, Procedure<Boolean> procedure) {
		graph.forHasStatement(subject, relation, object, procedure);	
	}
	
	@Override
	public void forHasStatement(Resource subject, Resource relation,
			Resource object, SyncListener<Boolean> procedure) {
		graph.forHasStatement(subject, relation, object, procedure);	
	}
	
	@Override
	public void forHasStatement(Resource subject, Resource relation,
			Resource object, SyncProcedure<Boolean> procedure) {
		graph.forHasStatement(subject, relation, object, procedure);	
	}
	
	@Override
	public void forHasStatement(Resource subject, Resource relation,
			SyncListener<Boolean> procedure) {
		graph.forHasStatement(subject, relation,  procedure);	
	}
	
	@Override
	public void forHasStatement(Resource subject, Resource relation,
			SyncProcedure<Boolean> procedure) {
		graph.forHasStatement(subject, relation, procedure);	
	}
	
	@Override
	public void forHasStatement(Resource subject,
			SyncListener<Boolean> procedure) {
		graph.forHasStatement(subject,  procedure);	
	}
	
	@Override
	public void forHasStatement(Resource subject,
			SyncProcedure<Boolean> procedure) {
		graph.forHasStatement(subject,  procedure);	
	}
	
	@Override
	public void forHasValue(Resource subject,
			AsyncListener<Boolean> procedure) {
		graph.forHasValue(subject, procedure);
	}
	
	@Override
	public void forHasValue(Resource subject,
			AsyncProcedure<Boolean> procedure) {
		graph.forHasValue(subject, procedure);	
	}
	
	@Override
	public void forHasValue(Resource subject, Listener<Boolean> procedure) {
		graph.forHasValue(subject, procedure);	
	}
	
	@Override
	public void forHasValue(Resource subject, Procedure<Boolean> procedure) {
		graph.forHasValue(subject, procedure);	
	}
	
	@Override
	public void forHasValue(Resource subject,
			SyncListener<Boolean> procedure) {
		graph.forHasValue(subject, procedure);	
	}
	
	@Override
	public void forHasValue(Resource subject,
			SyncProcedure<Boolean> procedure) {
		graph.forHasValue(subject, procedure);	
	}
	
	@Override
	public void forInverse(Resource relation,
			AsyncListener<Resource> procedure) {
		graph.forInverse(relation, procedure);
	}

	@Override
	public <T> T getService(Class<T> api) throws ServiceNotFoundException {
		return graph.getService(api);
	}

	@Override
	public <T> T peekService(Class<T> api) {
		return graph.peekService(api);
	}

	@Override
	public boolean hasService(Class<?> api) {
		return graph.hasService(api);
	}

	@Override
	public <T> void registerService(Class<T> api, T service) {
		graph.registerService(api, service);
	}

	@Override
	public String getURI(Resource resource)
			throws ValidationException,
			ServiceException, AssumptionException {
		return graph.getURI(resource);
	}

	@Override
	public String getPossibleURI(Resource resource)
			throws ValidationException,
			ServiceException {
		return graph.getPossibleURI(resource);
	}

	@Override
	public Resource getResource(String uri)
			throws ResourceNotFoundException, ValidationException,
			ServiceException {
		return graph.getResource(uri);
	}

	@Override
	public Resource getPossibleResource(String uri)
			throws ResourceNotFoundException, ValidationException,
			ServiceException {
		return graph.getPossibleResource(uri);
	}

	@Override
	public Collection<Statement> getStatements(Resource subject,
			Resource relation)
			throws ManyObjectsForFunctionalRelationException,
			ServiceException {
		return graph.getStatements(subject, relation);
	}

	@Override
	public Collection<Statement> getAssertedStatements(Resource subject,
			Resource relation)
			throws ManyObjectsForFunctionalRelationException,
			ServiceException {
		return graph.getAssertedStatements(subject, relation);
	}

	@Override
	public Collection<Resource> getPredicates(Resource subject)
			throws ServiceException {
		return graph.getPredicates(subject);
	}

	@Override
	public Collection<Resource> getPrincipalTypes(Resource subject)
			throws ServiceException {
		return graph.getPrincipalTypes(subject);
	}

	@Override
	public Set<Resource> getTypes(Resource subject) throws ServiceException {
		return graph.getTypes(subject);
	}

	@Override
	public Set<Resource> getSupertypes(Resource subject)
			throws ServiceException {
		return graph.getSupertypes(subject);
	}

	@Override
	public Set<Resource> getSuperrelations(Resource subject)
			throws ServiceException {
		return graph.getSuperrelations(subject);
	}

	@Override
	public Resource getPossibleSuperrelation(Resource subject)
			throws ServiceException {
		return graph.getPossibleSuperrelation(subject);
	}

//	@Override
//	public Collection<Resource> getObjects(Resource subject,
//			Resource relation)
//			throws ManyObjectsForFunctionalRelationException,
//			ServiceException {
//		return graph.getObjects(subject, relation);
//	}

	@Override
	public Collection<Resource> getAssertedObjects(Resource subject,
			Resource relation)
			throws ManyObjectsForFunctionalRelationException,
			ServiceException {
		return graph.getAssertedObjects(subject, relation);
	}

	@Override
	public Resource getInverse(Resource relation)
			throws NoInverseException,
			ManyObjectsForFunctionalRelationException, ServiceException {
		return graph.getInverse(relation);
	}

	@Override
	public Resource getSingleObject(Resource subject, Resource relation)
			throws NoSingleResultException,
			ManyObjectsForFunctionalRelationException, ServiceException {
		return graph.getSingleObject(subject, relation);
	}

	@Override
	public Statement getSingleStatement(Resource subject, Resource relation)
			throws NoSingleResultException,
			ManyObjectsForFunctionalRelationException, ServiceException {
		return graph.getSingleStatement(subject, relation);
	}

	@Override
	public Resource getSingleType(Resource subject)
			throws NoSingleResultException, ServiceException {
		return graph.getSingleType(subject);
	}

	@Override
	public Resource getSingleType(Resource subject, Resource baseType)
			throws NoSingleResultException, ServiceException {
		return graph.getSingleType(subject, baseType);
	}

	@Override
	public <T> T getValue(Resource subject)
			throws DoesNotContainValueException, ServiceException {
		return graph.getValue(subject);
	}

	@Override
	public <T> T getValue(Resource subject, Binding binding)
			throws DoesNotContainValueException, BindingException,
			ServiceException {
		return graph.getValue(subject, binding);
	}

	@Override
	public <T> T getRelatedValue(Resource subject, Resource relation)
			throws NoSingleResultException, DoesNotContainValueException,
			ServiceException {
		return graph.getRelatedValue(subject, relation);
	}

	@Override
	public <T> T getRelatedValue(Resource subject, Resource relation,
			Binding binding) throws NoSingleResultException,
			DoesNotContainValueException, BindingException,
			ServiceException {
		return graph.getRelatedValue(subject, relation, binding);
	}

	@Override
	public Resource getPossibleInverse(Resource relation)
			throws ManyObjectsForFunctionalRelationException,
			ServiceException {
		return graph.getPossibleInverse(relation);
	}

	@Override
	public Resource getPossibleObject(Resource subject, Resource relation)
			throws ManyObjectsForFunctionalRelationException,
			ServiceException {
		return graph.getPossibleObject(subject, relation);
	}

	@Override
	public Statement getPossibleStatement(Resource subject,
			Resource relation)
			throws ManyObjectsForFunctionalRelationException,
			ServiceException {
		return graph.getPossibleStatement(subject, relation);
	}

	@Override
	public Resource getPossibleType(Resource subject, Resource baseType)
			throws ServiceException {
		return graph.getPossibleType(subject, baseType);
	}

	@Override
	public <T> T getPossibleValue(Resource subject) throws ServiceException {
		return graph.getPossibleValue(subject);
	}

	@Override
	public <T> T getPossibleValue(Resource subject, Binding binding)
			throws BindingException, ServiceException {
		return graph.getPossibleValue(subject, binding);
	}

	@Override
	public <T> T getPossibleRelatedValue(Resource subject, Resource relation)
			throws ManyObjectsForFunctionalRelationException,
			ServiceException {
		return graph.getPossibleRelatedValue(subject, relation);
	}

	@Override
	public <T> T getPossibleRelatedValue(Resource subject,
			Resource relation, Binding binding)
			throws ManyObjectsForFunctionalRelationException,
			BindingException, ServiceException {
		return graph.getPossibleRelatedValue(subject, relation, binding);
	}

	@Override
	public <T> T getPossibleAdapter(Resource resource, Class<T> clazz)
			throws ValidationException, ServiceException {
		return graph.getPossibleAdapter(resource, clazz);
	}

	@Override
	public <T> T getPossibleUniqueAdapter(Resource resource, Class<T> clazz)
			throws ValidationException, ServiceException {
		return graph.getPossibleUniqueAdapter(resource, clazz);
	}

	@Override
	public boolean isInstanceOf(Resource resource, Resource type)
			throws ServiceException {
		return graph.isInstanceOf(resource, type);
	}

	@Override
	public boolean isInheritedFrom(Resource resource, Resource type)
			throws ServiceException {
		return graph.isInheritedFrom(resource, type);
	}

	@Override
	public boolean isSubrelationOf(Resource resource, Resource relation)
			throws ServiceException {
		return graph.isSubrelationOf(resource, relation);
	}

	@Override
	public boolean hasStatement(Resource subject) throws ServiceException {
		return graph.hasStatement(subject);
	}

	@Override
	public boolean hasStatement(Resource subject, Resource relation)
			throws ServiceException {
		return graph.hasStatement(subject, relation);
	}

	@Override
	public boolean hasStatement(Resource subject, Resource relation,
			Resource object) throws ServiceException {
		return graph.hasStatement(subject, relation, object);
	}

	@Override
	public boolean hasValue(Resource subject) throws ServiceException {
		return graph.hasValue(subject);
	}

	@Override
	public Datatype getDataType(Resource subject) throws DatabaseException {
		return graph.getDataType(subject);
	}

	@Override
	public <T extends Accessor> T getAccessor(Resource subject)
			throws DatabaseException {
		return graph.getAccessor(subject);
	}

    @Override
    public RandomAccessBinary getRandomAccessBinary(Resource subject)
            throws DatabaseException {
        return graph.getRandomAccessBinary(subject);
    }

	@Override
	public <T> T syncRequest(Read<T> request) throws DatabaseException {
		return graph.syncRequest(request);
	}

	@Override
	public <T> T syncRequest(Read<T> request, AsyncListener<T> procedure)
			throws DatabaseException {
		return graph.syncRequest(request, procedure);
	}

	@Override
	public <T> T syncRequest(Read<T> request, SyncListener<T> procedure)
			throws DatabaseException {
		return graph.syncRequest(request, procedure);
	}

	@Override
	public <T> T syncRequest(Read<T> request, Listener<T> procedure)
			throws DatabaseException {
		return graph.syncRequest(request, procedure);
	}

	@Override
	public <T> T syncRequest(Read<T> request, AsyncProcedure<T> procedure)
			throws DatabaseException {
		return graph.syncRequest(request, procedure);
	}

	@Override
	public <T> T syncRequest(Read<T> request, SyncProcedure<T> procedure)
			throws DatabaseException {
		return graph.syncRequest(request, procedure);
	}

	@Override
	public <T> T syncRequest(Read<T> request, Procedure<T> procedure)
			throws DatabaseException {
		return graph.syncRequest(request, procedure);
	}

	@Override
	public <T> T syncRequest(AsyncRead<T> request) throws DatabaseException {
		return graph.syncRequest(request);
	}

	@Override
	public <T> T syncRequest(AsyncRead<T> request,
			AsyncListener<T> procedure) throws DatabaseException {
		return graph.syncRequest(request, procedure);
	}

	@Override
	public <T> T syncRequest(AsyncRead<T> request, SyncListener<T> procedure)
			throws DatabaseException {
		return graph.syncRequest(request, procedure);
	}

	@Override
	public <T> T syncRequest(AsyncRead<T> request, Listener<T> procedure)
			throws DatabaseException {
		return graph.syncRequest(request, procedure);
	}

	@Override
	public <T> T syncRequest(AsyncRead<T> request,
			AsyncProcedure<T> procedure) throws DatabaseException {
		return graph.syncRequest(request, procedure);
	}

	@Override
	public <T> T syncRequest(AsyncRead<T> request,
			SyncProcedure<T> procedure) throws DatabaseException {
		return graph.syncRequest(request, procedure);
	}

	@Override
	public <T> T syncRequest(AsyncRead<T> request, Procedure<T> procedure)
			throws DatabaseException {
		return graph.syncRequest(request, procedure);
	}

	@Override
	public <T> Collection<T> syncRequest(MultiRead<T> request)
			throws DatabaseException {
		return graph.syncRequest(request);
	}

	@Override
	public <T> Collection<T> syncRequest(MultiRead<T> request,
			AsyncMultiListener<T> procedure) throws DatabaseException {
		return graph.syncRequest(request, procedure);
	}

	@Override
	public <T> Collection<T> syncRequest(MultiRead<T> request,
			SyncMultiListener<T> procedure) throws DatabaseException {
		return graph.syncRequest(request, procedure);
	}

	@Override
	public <T> Collection<T> syncRequest(MultiRead<T> request,
			MultiListener<T> procedure) throws DatabaseException {
		return graph.syncRequest(request, procedure);
	}

	@Override
	public <T> Collection<T> syncRequest(MultiRead<T> request,
			AsyncMultiProcedure<T> procedure) throws DatabaseException {
		return graph.syncRequest(request, procedure);
	}

	@Override
	public <T> Collection<T> syncRequest(MultiRead<T> request,
			SyncMultiProcedure<T> procedure) throws DatabaseException {
		return graph.syncRequest(request, procedure);
	}

	@Override
	public <T> Collection<T> syncRequest(MultiRead<T> request,
			MultiProcedure<T> procedure) throws DatabaseException {
		return graph.syncRequest(request, procedure);
	}

	@Override
	public <T> Collection<T> syncRequest(AsyncMultiRead<T> request)
			throws DatabaseException {
		return graph.syncRequest(request);
	}

	@Override
	public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
			AsyncMultiListener<T> procedure) throws DatabaseException {
		return graph.syncRequest(request, procedure);
	}

	@Override
	public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
			SyncMultiListener<T> procedure) throws DatabaseException {
		return graph.syncRequest(request, procedure);
	}

	@Override
	public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
			MultiListener<T> procedure) throws DatabaseException {
		return graph.syncRequest(request, procedure);
	}

	@Override
	public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
			AsyncMultiProcedure<T> procedure) throws DatabaseException {
		return graph.syncRequest(request, procedure);
	}

	@Override
	public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
			SyncMultiProcedure<T> procedure) throws DatabaseException {
		return graph.syncRequest(request, procedure);
	}

	@Override
	public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
			MultiProcedure<T> procedure) throws DatabaseException {
		return graph.syncRequest(request, procedure);
	}

	@Override
	public <T> T syncRequest(ExternalRead<T> request)
			throws DatabaseException {
		return graph.syncRequest(request);
	}

	@Override
	public <T> T syncRequest(ExternalRead<T> request, Listener<T> procedure)
			throws DatabaseException {
		return graph.syncRequest(request, procedure);
	}

	@Override
	public <T> T syncRequest(ExternalRead<T> request, Procedure<T> procedure)
			throws DatabaseException {
		return graph.syncRequest(request, procedure);
	}

	@Override
	public void syncRequest(Write request) throws DatabaseException {
		graph.syncRequest(request);
	}

	@Override
	public void syncRequest(DelayedWrite request) throws DatabaseException {
		graph.syncRequest(request);
	}

	@Override
	public void syncRequest(WriteOnly r) throws DatabaseException {
		graph.syncRequest(r);
	}

	@Override
	public <T> T syncRequest(WriteResult<T> request)
			throws DatabaseException {
		return graph.syncRequest(request);
	}

	@Override
	public <T> T syncRequest(DelayedWriteResult<T> request)
			throws DatabaseException {
		return graph.syncRequest(request);
	}

	@Override
	public <T> T syncRequest(WriteOnlyResult<T> r) throws DatabaseException {
		return graph.syncRequest(r);
	}

	@Override
	public void forURI(Resource resource, AsyncListener<String> procedure) {
		graph.forURI(resource, procedure);
	}

	@Override
	public void forURI(Resource resource, SyncListener<String> procedure) {
		graph.forURI(resource, procedure);
	}

	@Override
	public void forURI(Resource resource, Listener<String> procedure) {
		graph.forURI(resource, procedure);
	}

	@Override
	public void forURI(Resource resource, AsyncProcedure<String> procedure) {
		graph.forURI(resource, procedure);
	}

	@Override
	public void forURI(Resource resource, SyncProcedure<String> procedure) {
		graph.forURI(resource, procedure);
	}

	@Override
	public void forURI(Resource resource, Procedure<String> procedure) {
		graph.forURI(resource, procedure);
	}

	@Override
	public void forResource(String id, AsyncListener<Resource> procedure) {
		graph.forResource(id, procedure);
	}

	@Override
	public void forResource(String id, SyncListener<Resource> procedure) {
		graph.forResource(id, procedure);
	}

	@Override
	public void forResource(String id, Listener<Resource> procedure) {
		graph.forResource(id, procedure);
	}

	@Override
	public void forResource(String id, AsyncProcedure<Resource> procedure) {
		graph.forResource(id, procedure);
	}

	@Override
	public void forResource(String id, SyncProcedure<Resource> procedure) {
		graph.forResource(id, procedure);
	}

	@Override
	public void forResource(String id, Procedure<Resource> procedure) {
		graph.forResource(id, procedure);
	}

	@Override
	public void forStatementSet(Resource subject, Resource relation,
			AsyncSetListener<Statement> procedure) {
		graph.forStatementSet(subject, relation, procedure);
	}

	@Override
	public void forStatementSet(Resource subject, Resource relation,
			SyncSetListener<Statement> procedure) {
		graph.forStatementSet(subject, relation, procedure);
	}

	@Override
	public void forStatementSet(Resource subject, Resource relation,
			SetListener<Statement> procedure) {
		graph.forStatementSet(subject, relation, procedure);
	}

	@Override
	public void forPredicateSet(Resource subject,
			AsyncSetListener<Resource> procedure) {
		graph.forPredicateSet(subject, procedure);
	}

	@Override
	public void forPredicateSet(Resource subject,
			SyncSetListener<Resource> procedure) {
		graph.forPredicateSet(subject, procedure);
	}

	@Override
	public void forPredicateSet(Resource subject,
			SetListener<Resource> procedure) {
		graph.forPredicateSet(subject, procedure);
	}

	@Override
	public void forPrincipalTypeSet(Resource subject,
			AsyncSetListener<Resource> procedure) {
		graph.forPrincipalTypeSet(subject, procedure);
	}

	@Override
	public void forPrincipalTypeSet(Resource subject,
			SyncSetListener<Resource> procedure) {
		graph.forPrincipalTypeSet(subject, procedure);
	}

	@Override
	public void forPrincipalTypeSet(Resource subject,
			SetListener<Resource> procedure) {
		graph.forPrincipalTypeSet(subject, procedure);
	}

	@Override
	public void forTypes(Resource subject,
			AsyncListener<Set<Resource>> procedure) {
		graph.forTypes(subject, procedure);
	}

	@Override
	public void forTypes(Resource subject,
			SyncListener<Set<Resource>> procedure) {
		graph.forTypes(subject, procedure);
	}

	@Override
	public void forTypes(Resource subject, Listener<Set<Resource>> procedure) {
		graph.forTypes(subject, procedure);		
	}

	@Override
	public void forTypes(Resource subject,
			AsyncProcedure<Set<Resource>> procedure) {
		graph.forTypes(subject, procedure);		
	}

	@Override
	public void forTypes(Resource subject,
			SyncProcedure<Set<Resource>> procedure) {
		graph.forTypes(subject, procedure);		
	}

	@Override
	public void forTypes(Resource subject,
			Procedure<Set<Resource>> procedure) {
		graph.forTypes(subject, procedure);		
	}

	@Override
	public void forSupertypes(Resource subject,
			AsyncListener<Set<Resource>> procedure) {
		graph.forSupertypes(subject, procedure);		
	}

	@Override
	public void forSupertypes(Resource subject,
			SyncListener<Set<Resource>> procedure) {
		graph.forSupertypes(subject, procedure);
	}

	@Override
	public void forSupertypes(Resource subject,
			Listener<Set<Resource>> procedure) {
		graph.forSupertypes(subject, procedure);
	}

	@Override
	public void forSupertypes(Resource subject,
			AsyncProcedure<Set<Resource>> procedure) {
		graph.forSupertypes(subject, procedure);
	}

	@Override
	public void forSupertypes(Resource subject,
			SyncProcedure<Set<Resource>> procedure) {
		graph.forSupertypes(subject, procedure);
	}

	@Override
	public void forSupertypes(Resource subject,
			Procedure<Set<Resource>> procedure) {
		graph.forSupertypes(subject, procedure);
	}

	@Override
	public void forPossibleSuperrelation(Resource subject,
			AsyncProcedure<Resource> procedure) {
		graph.forPossibleSuperrelation(subject, procedure);		
	}

	@Override
	public void forSuperrelations(Resource subject,
			AsyncListener<Set<Resource>> procedure) {
		graph.forSuperrelations(subject, procedure);
	}

	@Override
	public void forSuperrelations(Resource subject,
			SyncListener<Set<Resource>> procedure) {
		graph.forSuperrelations(subject, procedure);
	}

	@Override
	public void forSuperrelations(Resource subject,
			Listener<Set<Resource>> procedure) {
		graph.forSuperrelations(subject, procedure);
	}

	@Override
	public void forSuperrelations(Resource subject,
			AsyncProcedure<Set<Resource>> procedure) {
		graph.forSuperrelations(subject, procedure);
	}

	@Override
	public void forSuperrelations(Resource subject,
			SyncProcedure<Set<Resource>> procedure) {
		graph.forSuperrelations(subject, procedure);
	}

	@Override
	public void forSuperrelations(Resource subject,
			Procedure<Set<Resource>> procedure) {
		graph.forSuperrelations(subject, procedure);
	}

	@Override
	public void forObjectSet(Resource subject, Resource relation,
			AsyncSetListener<Resource> procedure) {
		graph.forObjectSet(subject, relation, procedure);
	}

	@Override
	public void forObjectSet(Resource subject, Resource relation,
			SyncSetListener<Resource> procedure) {
		graph.forObjectSet(subject, relation, procedure);
	}

	@Override
	public void forObjectSet(Resource subject, Resource relation,
			SetListener<Resource> procedure) {
		graph.forObjectSet(subject, relation, procedure);
	}

	@Override
	public void forInverse(Resource relation,
			SyncListener<Resource> procedure) {
		graph.forInverse(relation, procedure);
	}

	@Override
	public void forInverse(Resource relation, Listener<Resource> procedure) {
		graph.forInverse(relation, procedure);
	}

	@Override
	public void forInverse(Resource relation,
			AsyncProcedure<Resource> procedure) {
		graph.forInverse(relation, procedure);
	}

	@Override
	public void forInverse(Resource relation,
			SyncProcedure<Resource> procedure) {
		graph.forInverse(relation, procedure);
	}

	@Override
	public void forInverse(Resource relation, Procedure<Resource> procedure) {
		graph.forInverse(relation, procedure);
	}

	@Override
	public void forSingleObject(Resource subject, Resource relation,
			AsyncListener<Resource> procedure) {
		graph.forSingleObject(subject, relation, procedure);
	}

	@Override
	public void forSingleObject(Resource subject, Resource relation,
			SyncListener<Resource> procedure) {
		graph.forSingleObject(subject, relation, procedure);
	}

	@Override
	public void forSingleObject(Resource subject, Resource relation,
			Listener<Resource> procedure) {
		graph.forSingleObject(subject, relation, procedure);		
	}

	@Override
	public void forSingleObject(Resource subject, Resource relation,
			AsyncProcedure<Resource> procedure) {
		graph.forSingleObject(subject, relation, procedure);		
	}

	@Override
	public void forSingleObject(Resource subject, Resource relation,
			SyncProcedure<Resource> procedure) {
		graph.forSingleObject(subject, relation, procedure);
	}

	@Override
	public void forSingleObject(Resource subject, Resource relation,
			Procedure<Resource> procedure) {
		graph.forSingleObject(subject, relation, procedure);
	}

	@Override
	public void forSingleStatement(Resource subject, Resource relation,
			AsyncListener<Statement> procedure) {
		graph.forSingleStatement(subject, relation, procedure);
	}

	@Override
	public void forSingleStatement(Resource subject, Resource relation,
			SyncListener<Statement> procedure) {
		graph.forSingleStatement(subject, relation, procedure);
	}

	@Override
	public void forSingleStatement(Resource subject, Resource relation,
			Listener<Statement> procedure) {
		graph.forSingleStatement(subject, relation, procedure);
	}

	@Override
	public void forSingleStatement(Resource subject, Resource relation,
			AsyncProcedure<Statement> procedure) {
		graph.forSingleStatement(subject, relation, procedure);
	}

	@Override
	public void forSingleStatement(Resource subject, Resource relation,
			SyncProcedure<Statement> procedure) {
		graph.forSingleStatement(subject, relation, procedure);
	}

	@Override
	public void forSingleStatement(Resource subject, Resource relation,
			Procedure<Statement> procedure) {
		graph.forSingleStatement(subject, relation, procedure);
	}

	@Override
	public void forSingleType(Resource subject,
			AsyncListener<Resource> procedure) {
		graph.forSingleType(subject, procedure);
	}

	@Override
	public void forSingleType(Resource subject,
			SyncListener<Resource> procedure) {
		graph.forSingleType(subject, procedure);
	}

	@Override
	public void forSingleType(Resource subject, Listener<Resource> procedure) {
		graph.forSingleType(subject, procedure);
	}

	@Override
	public void forSingleType(Resource subject,
			AsyncProcedure<Resource> procedure) {
		graph.forSingleType(subject, procedure);
	}

	@Override
	public void forSingleType(Resource subject,
			SyncProcedure<Resource> procedure) {
		graph.forSingleType(subject, procedure);
	}

	@Override
	public void forSingleType(Resource subject,
			Procedure<Resource> procedure) {
		graph.forSingleType(subject, procedure);
	}

	@Override
	public void forSingleType(Resource subject, Resource baseType,
			AsyncListener<Resource> procedure) {
		graph.forSingleType(subject, baseType, procedure);
	}

	@Override
	public void forSingleType(Resource subject, Resource baseType,
			SyncListener<Resource> procedure) {
		graph.forSingleType(subject, baseType, procedure);
	}

	@Override
	public void forSingleType(Resource subject, Resource baseType,
			Listener<Resource> procedure) {
		graph.forSingleType(subject, baseType, procedure);
	}

	@Override
	public void forSingleType(Resource subject, Resource baseType,
			AsyncProcedure<Resource> procedure) {
		graph.forSingleType(subject, baseType, procedure);
	}

	@Override
	public void forSingleType(Resource subject, Resource baseType,
			SyncProcedure<Resource> procedure) {
		graph.forSingleType(subject, baseType, procedure);
	}

	@Override
	public void forSingleType(Resource subject, Resource baseType,
			Procedure<Resource> procedure) {
		graph.forSingleType(subject, baseType, procedure);
	}

	@Override
	public <T> void forValue(Resource subject, AsyncListener<T> procedure) {
		graph.forValue(subject, procedure);
	}

	@Override
	public <T> void forValue(Resource subject, SyncListener<T> procedure) {
		graph.forValue(subject, procedure);
	}

	@Override
	public <T> void forValue(Resource subject, Listener<T> procedure) {
		graph.forValue(subject, procedure);
	}

	@Override
	public <T> void forValue(Resource subject, AsyncProcedure<T> procedure) {
		graph.forValue(subject, procedure);
	}

	@Override
	public <T> void forValue(Resource subject, SyncProcedure<T> procedure) {
		graph.forValue(subject, procedure);
	}

	@Override
	public <T> void forValue(Resource subject, Procedure<T> procedure) {
		graph.forValue(subject, procedure);
	}

	@Override
	public <T> void forValue(Resource subject, Binding binding,
			AsyncListener<T> procedure) {
		graph.forValue(subject, binding, procedure);
	}

	@Override
	public <T> void forValue(Resource subject, Binding binding,
			SyncListener<T> procedure) {
		graph.forValue(subject, binding, procedure);
	}

	@Override
	public <T> void forValue(Resource subject, Binding binding,
			Listener<T> procedure) {
		graph.forValue(subject, binding, procedure);
	}

	@Override
	public <T> void forValue(Resource subject, Binding binding,
			AsyncProcedure<T> procedure) {
		graph.forValue(subject, binding, procedure);
	}

	@Override
	public <T> void forValue(Resource subject, Binding binding,
			SyncProcedure<T> procedure) {
		graph.forValue(subject, binding, procedure);
	}

	@Override
	public <T> void forValue(Resource subject, Binding binding,
			Procedure<T> procedure) {
		graph.forValue(subject, binding, procedure);
	}

	@Override
	public <T> void forRelatedValue(Resource subject, Resource relation,
			AsyncListener<T> procedure) {
		graph.forRelatedValue(subject, relation, procedure);
	}

	@Override
	public <T> void forRelatedValue(Resource subject, Resource relation,
			SyncListener<T> procedure) {
		graph.forRelatedValue(subject, relation, procedure);
	}

	@Override
	public <T> void forRelatedValue(Resource subject, Resource relation,
			Listener<T> procedure) {
		graph.forRelatedValue(subject, relation, procedure);
	}

	@Override
	public <T> void forRelatedValue(Resource subject, Resource relation,
			AsyncProcedure<T> procedure) {
		graph.forRelatedValue(subject, relation, procedure);
	}

	@Override
	public <T> void forRelatedValue(Resource subject, Resource relation,
			SyncProcedure<T> procedure) {
		graph.forRelatedValue(subject, relation, procedure);
	}

	@Override
	public <T> void forRelatedValue(Resource subject, Resource relation,
			Procedure<T> procedure) {
		graph.forRelatedValue(subject, relation, procedure);
	}

	@Override
	public <T> void forRelatedValue(Resource subject, Resource relation,
			Binding binding, AsyncListener<T> procedure) {
		graph.forRelatedValue(subject, relation, binding, procedure);
	}

	@Override
	public <T> void forRelatedValue(Resource subject, Resource relation,
			Binding binding, SyncListener<T> procedure) {
		graph.forRelatedValue(subject, relation, binding, procedure);
	}

	@Override
	public <T> void forRelatedValue(Resource subject, Resource relation,
			Binding binding, Listener<T> procedure) {
		graph.forRelatedValue(subject, relation, binding, procedure);
	}

	@Override
	public <T> void forRelatedValue(Resource subject, Resource relation,
			Binding binding, AsyncProcedure<T> procedure) {
		graph.forRelatedValue(subject, relation, binding, procedure);
	}

	@Override
	public <T> void forRelatedValue(Resource subject, Resource relation,
			Binding binding, SyncProcedure<T> procedure) {
		graph.forRelatedValue(subject, relation, binding, procedure);
	}

	@Override
	public <T> void forRelatedValue(Resource subject, Resource relation,
			Binding binding, Procedure<T> procedure) {
		graph.forRelatedValue(subject, relation, binding, procedure);
	}

	@Override
	public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
			AsyncListener<T> procedure) {
		graph.forUniqueAdapted(resource, clazz, procedure);
	}

	@Override
	public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
			SyncListener<T> procedure) {
		graph.forUniqueAdapted(resource, clazz, procedure);
	}

	@Override
	public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
			Listener<T> procedure) {
		graph.forUniqueAdapted(resource, clazz, procedure);
	}

	@Override
	public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
			AsyncProcedure<T> procedure) {
		graph.forUniqueAdapted(resource, clazz, procedure);
	}

	@Override
	public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
			SyncProcedure<T> procedure) {
		graph.forUniqueAdapted(resource, clazz, procedure);
	}

	@Override
	public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
			Procedure<T> procedure) {
		graph.forUniqueAdapted(resource, clazz, procedure);
	}

	@Override
	public void forPossibleInverse(Resource relation,
			AsyncListener<Resource> procedure) {
		graph.forPossibleInverse(relation, procedure);
	}

	@Override
	public void forPossibleInverse(Resource relation,
			SyncListener<Resource> procedure) {
		graph.forPossibleInverse(relation, procedure);
	}

	@Override
	public void forPossibleInverse(Resource relation,
			Listener<Resource> procedure) {
		graph.forPossibleInverse(relation, procedure);
	}

	@Override
	public void forPossibleInverse(Resource relation,
			AsyncProcedure<Resource> procedure) {
		graph.forPossibleInverse(relation, procedure);
	}

	@Override
	public void forPossibleInverse(Resource relation,
			SyncProcedure<Resource> procedure) {
		graph.forPossibleInverse(relation, procedure);
	}

	@Override
	public void forPossibleInverse(Resource relation,
			Procedure<Resource> procedure) {
		graph.forPossibleInverse(relation, procedure);
	}

	@Override
	public void forPossibleObject(Resource subject, Resource relation,
			AsyncListener<Resource> procedure) {
		graph.forPossibleObject(subject, relation, procedure);
	}

	@Override
	public void forPossibleObject(Resource subject, Resource relation,
			SyncListener<Resource> procedure) {
		graph.forPossibleObject(subject, relation, procedure);
	}

	@Override
	public void forPossibleObject(Resource subject, Resource relation,
			Listener<Resource> procedure) {
		graph.forPossibleObject(subject, relation, procedure);
	}

	@Override
	public void forPossibleObject(Resource subject, Resource relation,
			AsyncProcedure<Resource> procedure) {
		graph.forPossibleObject(subject, relation, procedure);
	}

	@Override
	public void forPossibleObject(Resource subject, Resource relation,
			SyncProcedure<Resource> procedure) {
		graph.forPossibleObject(subject, relation, procedure);
	}

	@Override
	public void forPossibleObject(Resource subject, Resource relation,
			Procedure<Resource> procedure) {
		graph.forPossibleObject(subject, relation, procedure);
	}

	@Override
	public void forPossibleStatement(Resource subject, Resource relation,
			AsyncListener<Statement> procedure) {
		graph.forPossibleStatement(subject, relation, procedure);
	}

	@Override
	public void forPossibleStatement(Resource subject, Resource relation,
			SyncListener<Statement> procedure) {
		graph.forPossibleStatement(subject, relation, procedure);
	}

	@Override
	public void forPossibleStatement(Resource subject, Resource relation,
			Listener<Statement> procedure) {
		graph.forPossibleStatement(subject, relation, procedure);
	}

	@Override
	public void forPossibleStatement(Resource subject, Resource relation,
			AsyncProcedure<Statement> procedure) {
		graph.forPossibleStatement(subject, relation, procedure);
	}

	@Override
	public void forPossibleStatement(Resource subject, Resource relation,
			SyncProcedure<Statement> procedure) {
		graph.forPossibleStatement(subject, relation, procedure);
	}

	@Override
	public void forPossibleStatement(Resource subject, Resource relation,
			Procedure<Statement> procedure) {
		graph.forPossibleStatement(subject, relation, procedure);
	}

	@Override
	public void forPossibleType(Resource subject, Resource baseType,
			AsyncListener<Resource> procedure) {
		graph.forPossibleType(subject, baseType, procedure);
	}

	@Override
	public void forPossibleType(Resource subject, Resource baseType,
			SyncListener<Resource> procedure) {
		graph.forPossibleType(subject, baseType, procedure);
	}

	@Override
	public void forPossibleType(Resource subject, Resource baseType,
			Listener<Resource> procedure) {
		graph.forPossibleType(subject, baseType, procedure);
	}

	@Override
	public void forPossibleType(Resource subject, Resource baseType,
			AsyncProcedure<Resource> procedure) {
		graph.forPossibleType(subject, baseType, procedure);
	}

	@Override
	public void forPossibleType(Resource subject, Resource baseType,
			SyncProcedure<Resource> procedure) {
		graph.forPossibleType(subject, baseType, procedure);
	}

	@Override
	public void forPossibleType(Resource subject, Resource baseType,
			Procedure<Resource> procedure) {
		graph.forPossibleType(subject, baseType, procedure);
	}

	@Override
	public <T> void forPossibleValue(Resource subject,
			AsyncListener<T> procedure) {
		graph.forPossibleValue(subject, procedure);
	}

	@Override
	public <T> void forPossibleValue(Resource subject,
			SyncListener<T> procedure) {
		graph.forPossibleValue(subject, procedure);
	}

	@Override
	public <T> void forPossibleValue(Resource subject, Listener<T> procedure) {
		graph.forPossibleValue(subject, procedure);
	}

	@Override
	public <T> void forPossibleValue(Resource subject,
			AsyncProcedure<T> procedure) {
		graph.forPossibleValue(subject, procedure);
	}

	@Override
	public <T> void forPossibleValue(Resource subject,
			SyncProcedure<T> procedure) {
		graph.forPossibleValue(subject, procedure);
	}

	@Override
	public <T> void forPossibleValue(Resource subject,
			Procedure<T> procedure) {
		graph.forPossibleValue(subject, procedure);
	}

	@Override
	public <T> void forPossibleValue(Resource subject, Binding binding,
			AsyncListener<T> procedure) {
		graph.forPossibleValue(subject, procedure);
	}

	@Override
	public <T> void forPossibleValue(Resource subject, Binding binding,
			SyncListener<T> procedure) {
		graph.forPossibleValue(subject, procedure);
	}

	@Override
	public <T> void forPossibleValue(Resource subject, Binding binding,
			Listener<T> procedure) {
		graph.forPossibleValue(subject, procedure);
	}

	@Override
	public <T> void forPossibleValue(Resource subject, Binding binding,
			AsyncProcedure<T> procedure) {
		graph.forPossibleValue(subject, procedure);
	}

	@Override
	public <T> void forPossibleValue(Resource subject, Binding binding,
			SyncProcedure<T> procedure) {
		graph.forPossibleValue(subject, procedure);
	}

	@Override
	public <T> void forPossibleValue(Resource subject, Binding binding,
			Procedure<T> procedure) {
		graph.forPossibleValue(subject, procedure);
	}

	@Override
	public <T> void forPossibleRelatedValue(Resource subject,
			Resource relation, AsyncListener<T> procedure) {
		graph.forPossibleRelatedValue(subject, relation, procedure);
	}

	@Override
	public <T> void forPossibleRelatedValue(Resource subject,
			Resource relation, SyncListener<T> procedure) {
		graph.forPossibleRelatedValue(subject, relation, procedure);
	}

	@Override
	public <T> void forPossibleRelatedValue(Resource subject,
			Resource relation, Listener<T> procedure) {
		graph.forPossibleRelatedValue(subject, relation, procedure);
	}

	@Override
	public <T> void forPossibleRelatedValue(Resource subject,
			Resource relation, AsyncProcedure<T> procedure) {
		graph.forPossibleRelatedValue(subject, relation, procedure);
	}

	@Override
	public <T> void forPossibleRelatedValue(Resource subject,
			Resource relation, SyncProcedure<T> procedure) {
		graph.forPossibleRelatedValue(subject, relation, procedure);
	}

	@Override
	public <T> void forPossibleRelatedValue(Resource subject,
			Resource relation, Procedure<T> procedure) {
		graph.forPossibleRelatedValue(subject, relation, procedure);
	}

	@Override
	public <T> void forPossibleRelatedValue(Resource subject,
			Resource relation, Binding binding, AsyncListener<T> procedure) {
		graph.forPossibleRelatedValue(subject, relation, binding, procedure);
	}

	@Override
	public <T> void forPossibleRelatedValue(Resource subject,
			Resource relation, Binding binding, SyncListener<T> procedure) {
		graph.forPossibleRelatedValue(subject, relation, procedure);
	}

	@Override
	public <T> void forPossibleRelatedValue(Resource subject,
			Resource relation, Binding binding, Listener<T> procedure) {
		graph.forPossibleRelatedValue(subject, relation, binding, procedure);
	}

	@Override
	public <T> void forPossibleRelatedValue(Resource subject,
			Resource relation, Binding binding, AsyncProcedure<T> procedure) {
		graph.forPossibleRelatedValue(subject, relation, binding, procedure);
	}

	@Override
	public <T> void forPossibleRelatedValue(Resource subject,
			Resource relation, Binding binding, SyncProcedure<T> procedure) {
		graph.forPossibleRelatedValue(subject, relation, binding, procedure);
	}

	@Override
	public <T> void forPossibleRelatedValue(Resource subject,
			Resource relation, Binding binding, Procedure<T> procedure) {
		graph.forPossibleRelatedValue(subject, relation, binding, procedure);
	}

	@Override
	public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
			AsyncListener<T> procedure) {
		graph.forPossibleAdapted(resource, clazz, procedure);
	}

	@Override
	public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
			SyncListener<T> procedure) {
		graph.forPossibleAdapted(resource, clazz, procedure);
	}

	@Override
	public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
			Listener<T> procedure) {
		graph.forPossibleAdapted(resource, clazz, procedure);
	}

	@Override
	public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
			AsyncProcedure<T> procedure) {
		graph.forPossibleAdapted(resource, clazz, procedure);
	}

	@Override
	public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
			SyncProcedure<T> procedure) {
		graph.forPossibleAdapted(resource, clazz, procedure);
	}

	@Override
	public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
			Procedure<T> procedure) {
		graph.forPossibleAdapted(resource, clazz, procedure);
	}

	@Override
	public <T> void forPossibleUniqueAdapted(Resource resource,
			Class<T> clazz, AsyncListener<T> procedure) {
		graph.forPossibleUniqueAdapted(resource, clazz, procedure);
	}

	@Override
	public <T> void forPossibleUniqueAdapted(Resource resource,
			Class<T> clazz, SyncListener<T> procedure) {
		graph.forPossibleUniqueAdapted(resource, clazz, procedure);
	}

	@Override
	public <T> void forPossibleUniqueAdapted(Resource resource,
			Class<T> clazz, Listener<T> procedure) {
		graph.forPossibleUniqueAdapted(resource, clazz, procedure);
	}

	@Override
	public <T> void forPossibleUniqueAdapted(Resource resource,
			Class<T> clazz, AsyncProcedure<T> procedure) {
		graph.forPossibleUniqueAdapted(resource, clazz, procedure);
	}

	@Override
	public <T> void forPossibleUniqueAdapted(Resource resource,
			Class<T> clazz, SyncProcedure<T> procedure) {
		graph.forPossibleUniqueAdapted(resource, clazz, procedure);
	}

	@Override
	public <T> void forPossibleUniqueAdapted(Resource resource,
			Class<T> clazz, Procedure<T> procedure) {
		graph.forPossibleUniqueAdapted(resource, clazz, procedure);
	}

	@Override
	public void forIsInstanceOf(Resource resource, Resource type,
			AsyncListener<Boolean> procedure) {
		graph.forIsInstanceOf(resource, type, procedure);
	}

	@Override
	public void forIsInstanceOf(Resource resource, Resource type,
			SyncListener<Boolean> procedure) {
		graph.forIsInstanceOf(resource, type, procedure);
	}

	@Override
	public void forIsInstanceOf(Resource resource, Resource type,
			Listener<Boolean> procedure) {
		graph.forIsInstanceOf(resource, type, procedure);
	}

	@Override
	public void forIsInstanceOf(Resource resource, Resource type,
			AsyncProcedure<Boolean> procedure) {
		graph.forIsInstanceOf(resource, type, procedure);
	}

	@Override
	public void forIsInstanceOf(Resource resource, Resource type,
			SyncProcedure<Boolean> procedure) {
		graph.forIsInstanceOf(resource, type, procedure);
	}

	@Override
	public void forIsInstanceOf(Resource resource, Resource type,
			Procedure<Boolean> procedure) {
		graph.forIsInstanceOf(resource, type, procedure);
	}

	@Override
	public void forIsInheritedFrom(Resource resource, Resource type,
			AsyncListener<Boolean> procedure) {
		graph.forIsInheritedFrom(resource, type, procedure);
	}

	@Override
	public void forIsInheritedFrom(Resource resource, Resource type,
			SyncListener<Boolean> procedure) {
		graph.forIsInheritedFrom(resource, type, procedure);
	}

	@Override
	public void forIsInheritedFrom(Resource resource, Resource type,
			Listener<Boolean> procedure) {
		graph.forIsInheritedFrom(resource, type, procedure);
	}

	@Override
	public void forIsInheritedFrom(Resource resource, Resource type,
			AsyncProcedure<Boolean> procedure) {
		graph.forIsInheritedFrom(resource, type, procedure);
	}

	@Override
	public void forIsInheritedFrom(Resource resource, Resource type,
			SyncProcedure<Boolean> procedure) {
		graph.forIsInheritedFrom(resource, type, procedure);
	}

	@Override
	public void forIsInheritedFrom(Resource resource, Resource type,
			Procedure<Boolean> procedure) {
		graph.forIsInheritedFrom(resource, type, procedure);
	}

	@Override
	public void forIsSubrelationOf(Resource resource, Resource relation,
			AsyncListener<Boolean> procedure) {
		graph.forIsSubrelationOf(resource, relation, procedure);
	}

	@Override
	public void forIsSubrelationOf(Resource resource, Resource relation,
			SyncListener<Boolean> procedure) {
		graph.forIsSubrelationOf(resource, relation, procedure);
	}

	@Override
	public void forIsSubrelationOf(Resource resource, Resource relation,
			Listener<Boolean> procedure) {
		graph.forIsSubrelationOf(resource, relation, procedure);
	}

	@Override
	public void forIsSubrelationOf(Resource resource, Resource relation,
			AsyncProcedure<Boolean> procedure) {
		graph.forIsSubrelationOf(resource, relation, procedure);
	}

	@Override
	public void forIsSubrelationOf(Resource resource, Resource relation,
			SyncProcedure<Boolean> procedure) {
		graph.forIsSubrelationOf(resource, relation, procedure);
	}

	@Override
	public void forIsSubrelationOf(Resource resource, Resource relation,
			Procedure<Boolean> procedure) {
		graph.forIsSubrelationOf(resource, relation, procedure);
	}

	@Override
	public void forOrderedSet(Resource subject,
			AsyncMultiListener<Resource> procedure) {
		graph.forOrderedSet(subject, procedure);
	}

	@Override
	public void forOrderedSet(Resource subject,
			SyncMultiListener<Resource> procedure) {
		graph.forOrderedSet(subject, procedure);
	}

	@Override
	public void forOrderedSet(Resource subject,
			MultiListener<Resource> procedure) {
		graph.forOrderedSet(subject, procedure);
	}

	@Override
	public void forOrderedSet(Resource subject,
			AsyncMultiProcedure<Resource> procedure) {
		graph.forOrderedSet(subject, procedure);
	}

	@Override
	public void forOrderedSet(Resource subject,
			SyncMultiProcedure<Resource> procedure) {
		graph.forOrderedSet(subject, procedure);
	}

	@Override
	public void forOrderedSet(Resource subject,
			MultiProcedure<Resource> procedure) {
		graph.forOrderedSet(subject, procedure);
	}

	@Override
	public int thread() {
		return graph.thread();
	}

	@Override
	public Session getSession() {
		return graph.getSession();
	}

	@Override
	public Resource getBuiltin(String id) throws ResourceNotFoundException,
			ServiceException {
		return graph.getBuiltin(id);
	}
	
	@Override
	public VirtualGraph getProvider() {
		return graph.getProvider();
	}

	@Override
	public boolean isImmutable(Resource resource) throws DatabaseException {
		return graph.isImmutable(resource);
	}

}