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.ReadGraph;
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.common.request.ReadRequest;
import org.simantics.db.common.request.WriteRequest;
import org.simantics.db.common.request.WriteResultRequest;
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;

/**
 * This is insane.
 * 
 * @author Marko Luukkainen <marko.luukkainen@vtt.fi>
 *
 */
public class SplittingWriteGraph implements WriteGraph {
	
	protected Session session;
	
	
	@Override
	public <T> T getRelatedValue2(final Resource subject, final Resource relation)
			throws DatabaseException {
		return session.syncRequest(new Read<T>() {
			@Override
			public T perform(ReadGraph graph) throws DatabaseException {
				return graph.getRelatedValue2(subject, relation);
			}
		});
		
	}
	
	@Override
	public <T> T getRelatedValue2(final Resource subject, final Resource relation, final Binding binding) throws DatabaseException {
		return session.syncRequest(new Read<T>() {
			@Override
			public T perform(ReadGraph graph) throws DatabaseException {
				return graph.getRelatedValue2(subject, relation, binding);
			}
		});
	}
	
	@Override
	public <T> T getRelatedValue2(final Resource subject, final Resource relation, final Object context) throws DatabaseException {
		return session.syncRequest(new Read<T>() {
			@Override
			public T perform(ReadGraph graph) throws DatabaseException {
				return graph.getRelatedValue2(subject, relation, context);
			}
		});
	}
	
	@Override
	public <T> T getRelatedValue2(final Resource subject, final Resource relation, final Object context, final Binding binding) throws DatabaseException {
		return session.syncRequest(new Read<T>() {
			@Override
			public T perform(ReadGraph graph) throws DatabaseException {
				return graph.getRelatedValue2(subject, relation, context, binding);
			}
		});
	}
	
	@Override
	public <T> T getPossibleRelatedValue2(final Resource subject, final Resource relation)
			throws DatabaseException {
		return session.syncRequest(new Read<T>() {
			@Override
			public T perform(ReadGraph graph) throws DatabaseException {
				return graph.getPossibleRelatedValue2(subject, relation);
			}
		});
	}
	
	@Override
	public <T> T getPossibleRelatedValue2(final Resource subject, final Resource relation, final Binding binding) throws DatabaseException {
		return session.syncRequest(new Read<T>() {
			@Override
			public T perform(ReadGraph graph) throws DatabaseException {
				return graph.getPossibleRelatedValue2(subject, relation, binding);
			}
		});
	}
	
	@Override
	public <T> T getPossibleRelatedValue2(final Resource subject, final Resource relation, final Object context) throws DatabaseException {
		return session.syncRequest(new Read<T>() {
			@Override
			public T perform(ReadGraph graph) throws DatabaseException {
				return graph.getPossibleRelatedValue2(subject, relation, context);
			}
		});
	}
	
	@Override
	public <T> T getPossibleRelatedValue2(final Resource subject, final Resource relation, final Object context, final Binding binding) throws DatabaseException {
		return session.syncRequest(new Read<T>() {
			@Override
			public T perform(ReadGraph graph) throws DatabaseException {
				return graph.getPossibleRelatedValue2(subject, relation, context, binding);
			}
		});
	}
	
	@Override
	public <T> void async(final ReadInterface<T> r, final AsyncListener<T> procedure) {
		session.async(r, procedure);
		
	}
	
	@Override
	public <T> void async(final ReadInterface<T> r, final AsyncProcedure<T> procedure) {
		session.async(r, procedure);
	}
	
	@Override
	public <T> void async(final ReadInterface<T> r, final Listener<T> procedure) {
		session.async(r, procedure);
	}
	
	@Override
	public <T> void async(final ReadInterface<T> r, final Procedure<T> procedure) {
		session.async(r, procedure);
	}
	
	@Override
	public <T> void async(final ReadInterface<T> r, final SyncListener<T> procedure) {
		session.async(r, procedure);
	}
	
	@Override
	public <T> void async(final ReadInterface<T> r, final SyncProcedure<T> procedure) {
		session.async(r, procedure);
	}
	
	@Override
	public <T> void async(final WriteInterface<T> r) {
		session.async(r);
	}
	
	@Override
	public <T> void async(final WriteInterface<T> r, final Procedure<T> procedure) {
		session.async(r, procedure);
	}
	
	@Override
	public <T> T sync(final ReadInterface<T> r) throws DatabaseException {
		return session.sync(r);
	}
	
	@Override
	public <T> T sync(final WriteInterface<T> r) throws DatabaseException {
		return session.sync(r);
	}
	
	@Override
	public Resource getRootLibrary() {
		try {
			return session.syncRequest(new Read<Resource>() {
				
				@Override
				public Resource perform(ReadGraph graph) throws DatabaseException {
					return graph.getRootLibrary();
				}
			});
		} catch (DatabaseException e) {
			return null;
		}
	}
	
	
	@Override
	public void clearUndoList(final WriteTraits writeTraits) {
		throw new RuntimeException("Not supported.");
	}
	
	@Override
	public void combineWithPrevious(WriteTraits writeTraits) {
		throw new RuntimeException("Not supported.");
	}
	
	@Override
	public TreeMap<String, byte[]> getMetadata() {
		try {
			return session.syncRequest(new WriteResultRequest<TreeMap<String, byte[]>>() {
				
				@Override
				public TreeMap<String, byte[]> perform(WriteGraph graph) throws DatabaseException {
					return graph.getMetadata();
				}
			});
		} catch (DatabaseException e) {
			return null;
		}
	}
	
	@Override
	public <T extends Metadata> T getMetadata(final Class<T> clazz)
			throws ServiceException {
		try {
			return session.syncRequest(new WriteResultRequest<T>() {
				
				@Override
				public T perform(WriteGraph graph) throws DatabaseException {
					return graph.getMetadata(clazz);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}
	
	@Override
	public Type getRelatedValueType(final Resource subject, final Resource relation)
			throws DatabaseException {

		return session.syncRequest(new Read<Type>() {
			
			@Override
			public Type perform(ReadGraph graph) throws DatabaseException {
				return graph.getRelatedValueType(subject, relation);
			}
		});
		
	}
	
	@Override
	public void deny(final Resource subject, final Resource predicate, final Resource inverse, final Resource object, final VirtualGraph vgraph) throws ServiceException {
		try {
			session.syncRequest(new WriteRequest() {
				
				@Override
				public void perform(WriteGraph graph) throws DatabaseException {
					graph.deny(subject, predicate, inverse, object, vgraph);
					
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}
	
	
	
	
	@Override
	public <T> T adaptRelated(final Resource resource, final Resource relation,
			final Class<T> clazz) throws AdaptionException, NoSingleResultException,
			ValidationException, ServiceException {
		try {
			return session.syncRequest(new Read<T>() {
				
				@Override
				public T perform(ReadGraph graph) throws DatabaseException {
					return graph.adaptRelated(resource, relation, clazz);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}
	
	@Override
	public <T> T getPossibleRelatedAdapter(final Resource resource,
			final Resource relation, final Class<T> clazz) throws ValidationException,
			ServiceException {
		try {
			return session.syncRequest(new Read<T>() {
				
				@Override
				public T perform(ReadGraph graph) throws DatabaseException {
					return graph.getPossibleRelatedAdapter(resource, relation, clazz);
				}
			});
		} catch (DatabaseException e) {
			throw new ValidationException(e);
		}
	}
	
	@Override
	public void inc() {
		throw new RuntimeException("Not supported.");
	}
	
	@Override
	public void dec() {
		throw new RuntimeException("Not supported.");
	}
	
	@Override
	public Collection<Resource> getObjects(final Resource subject, final Resource relation) throws ServiceException 
			{
		try {
			return session.syncRequest(new Read<Collection<Resource>>() {
				
				@Override
				public Collection<Resource> perform(ReadGraph graph) throws DatabaseException {
					return graph.getObjects(subject, relation);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
		
	}
	
	@Override
	public <T extends Accessor> T newLiteral(final Resource resource,
	final Resource predicate, final Datatype datatype, final Object initialValue)
	throws DatabaseException {
		return session.syncRequest(new WriteResultRequest<T>() {
			
			@Override
			public T perform(WriteGraph graph) throws DatabaseException {
				return graph.newLiteral(resource, predicate, datatype, initialValue);
			}
		});
	}

	public RandomAccessBinary createRandomAccessBinary(final Resource resource, final Resource predicate, final Datatype datatype, final Object initialValue) throws DatabaseException {
        return session.syncRequest(new WriteResultRequest<RandomAccessBinary>() {
            @Override
            public RandomAccessBinary perform(WriteGraph graph) throws DatabaseException {
                return graph.createRandomAccessBinary(resource, predicate, datatype, initialValue);
            }
        });
    }

    public RandomAccessBinary createRandomAccessBinary(final Resource resource, final Datatype datatype, final Object initialValue) throws DatabaseException {
        return session.syncRequest(new WriteResultRequest<RandomAccessBinary>() {
            @Override
            public RandomAccessBinary perform(WriteGraph graph) throws DatabaseException {
                return graph.createRandomAccessBinary(resource, datatype, initialValue);
            }
        });
    }

	public <T, C> T adaptContextual(final Resource resource, final  C context, final java.lang.Class<C> contextClass, final java.lang.Class<T> clazz) throws AdaptionException ,NoSingleResultException ,ValidationException ,ServiceException {
		try {
			return session.syncRequest(new Read<T>() {
				
				@Override
				public T perform(ReadGraph graph) throws DatabaseException {
					return graph.adaptContextual(resource, context, contextClass, clazz);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
		
	};
	
	public <T, C> T getPossibleContextualAdapter(final Resource resource, final C context, final java.lang.Class<C> contextClass, final java.lang.Class<T> clazz) throws ValidationException ,ServiceException {
		try {
			return session.syncRequest(new Read<T>() {
				
				@Override
				public T perform(ReadGraph graph) throws DatabaseException {
					return graph.getPossibleContextualAdapter(resource, context, contextClass, clazz);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	};
	
	
	public SplittingWriteGraph(Session session) {
		this.session = session;
	}
	
	@Override
	public Resource newResource() throws ServiceException {
		try {
			return session.syncRequest(new WriteResultRequest<Resource>() {
				
				@Override
				public Resource perform(WriteGraph graph) throws DatabaseException {
					return graph.newResource();
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
		 
	}
	
	@Override
	public Resource newResource(final long clusterId) throws ServiceException {
		try {
			return session.syncRequest(new WriteResultRequest<Resource>() {
				
				@Override
				public Resource perform(WriteGraph graph) throws DatabaseException {
					return graph.newResource(clusterId);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}
	
	@Override
	public <T> T adapt(final Resource resource, final Class<T> clazz)
			throws AdaptionException, ValidationException, ServiceException {
		try {
			return session.syncRequest(new Read<T>() {
				
				@Override
				public T perform(ReadGraph graph) throws DatabaseException {
					return graph.adapt(resource, clazz);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}
	
	@Override
	public <T> T adaptUnique(final Resource resource, final Class<T> clazz)
			throws AdaptionException, ValidationException, ServiceException {
		try {
			return session.syncRequest(new Read<T>() {
				
				@Override
				public T perform(ReadGraph graph) throws DatabaseException {
					return graph.adaptUnique(resource, clazz);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}
	
	@Override
	public void addLiteral(final Resource resource, final Resource predicate,
			final Resource inverse, final Object value, final Binding binding)
			throws BindingException,
			ManyObjectsForFunctionalRelationException, ServiceException {
		try {
			session.syncRequest(new WriteRequest() {
				
				@Override
				public void perform(WriteGraph graph) throws DatabaseException {
					graph.addLiteral(resource, predicate, inverse, value, binding);
					
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}
	
	@Override
	public void addLiteral(final Resource resource, final Resource predicate,
			final Resource inverse, final Resource type, final Object value, final Binding binding)
			throws BindingException,
			ManyObjectsForFunctionalRelationException, ServiceException {
		try {
			session.syncRequest(new WriteRequest() {
				
				@Override
				public void perform(WriteGraph graph) throws DatabaseException {
					graph.addLiteral(resource, predicate, inverse, type, value, binding);
					
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}
	
	@Override
	public <T> void addMetadata(Metadata data) throws ServiceException {
		throw new RuntimeException("Not supported.");
	}
	
	@Override
	@Deprecated
	public void addValue(final Resource resource, final Resource predicate,
			final Resource inverse, final Resource type, final Object value, final Binding binding)
			throws BindingException,
			ManyObjectsForFunctionalRelationException, ServiceException {
		try {
			session.syncRequest(new WriteRequest() {
				
				@Override
				public void perform(WriteGraph graph) throws DatabaseException {
					graph.addValue(resource, predicate, inverse, type, value, binding);
					
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}
	
	@Override
	public <T> void asyncRequest(final AsyncMultiRead<T> request) {
		session.asyncRequest(request);
	}
	
	@Override
	public <T> void asyncRequest(AsyncMultiRead<T> request,
			AsyncMultiListener<T> procedure) {
		session.asyncRequest(request,procedure);
	}
	
	@Override
	public <T> void asyncRequest(AsyncMultiRead<T> request,
			AsyncMultiProcedure<T> procedure) {
		session.asyncRequest(request,procedure);
	}
	
	@Override
	public <T> void asyncRequest(AsyncMultiRead<T> request,
			MultiListener<T> procedure) {
		session.asyncRequest(request,procedure);
	}
	
	@Override
	public <T> void asyncRequest(AsyncMultiRead<T> request,
			MultiProcedure<T> procedure) {
		session.asyncRequest(request,procedure);
	}
	
	@Override
	public <T> void asyncRequest(AsyncMultiRead<T> request,
			SyncMultiListener<T> procedure) {
		session.asyncRequest(request,procedure);
	}
	
	@Override
	public <T> void asyncRequest(AsyncMultiRead<T> request,
			SyncMultiProcedure<T> procedure) {
		session.asyncRequest(request,procedure);	
	}
	
	@Override
	public <T> void asyncRequest(AsyncRead<T> request) {
		session.asyncRequest(request);	
	}
	
	@Override
	public <T> void asyncRequest(AsyncRead<T> request,
			AsyncListener<T> procedure) {
		session.asyncRequest(request,procedure);	
	}
	
	@Override
	public <T> void asyncRequest(AsyncRead<T> request,
			AsyncProcedure<T> procedure) {
		session.asyncRequest(request,procedure);	
	}
	
	@Override
	public <T> void asyncRequest(AsyncRead<T> request, Listener<T> procedure) {
		session.asyncRequest(request,procedure);	
	}
	
	@Override
	public <T> void asyncRequest(AsyncRead<T> request,
			Procedure<T> procedure) {
		session.asyncRequest(request,procedure);	
	}
	
	@Override
	public <T> void asyncRequest(AsyncRead<T> request,
			SyncListener<T> procedure) {
		session.asyncRequest(request,procedure);	
	}
	
	@Override
	public <T> void asyncRequest(AsyncRead<T> request,
			SyncProcedure<T> procedure) {
		session.asyncRequest(request,procedure);	
	}
	
	@Override
	public void asyncRequest(DelayedWrite request) {
		session.asyncRequest(request);	
	}
	
	@Override
	public void asyncRequest(DelayedWrite request,
			Callback<DatabaseException> callback) {
		session.asyncRequest(request,callback);	
	}
	
	@Override
	public <T> void asyncRequest(DelayedWriteResult<T> r,
			Procedure<T> procedure) {
		session.asyncRequest(r,procedure);	
	}
	
	@Override
	public <T> void asyncRequest(ExternalRead<T> request) {
		session.asyncRequest(request);	
	}
	
	@Override
	public <T> void asyncRequest(ExternalRead<T> request,
			Listener<T> procedure) {
		session.asyncRequest(request,procedure);
	}	
	
	@Override
	public <T> void asyncRequest(ExternalRead<T> request,
			Procedure<T> procedure) {
		session.asyncRequest(request,procedure);
	}
	
	@Override
	public <T> void asyncRequest(MultiRead<T> request) {
		session.asyncRequest(request);	
	}
	
	@Override
	public <T> void asyncRequest(MultiRead<T> request,
			AsyncMultiListener<T> procedure) {
		session.asyncRequest(request,procedure);	
	}
	
	@Override
	public <T> void asyncRequest(MultiRead<T> request,
			AsyncMultiProcedure<T> procedure) {
		session.asyncRequest(request,procedure);	
	}
	
	@Override
	public <T> void asyncRequest(MultiRead<T> request,
			MultiListener<T> procedure) {
		session.asyncRequest(request,procedure);	
	}
	
	@Override
	public <T> void asyncRequest(MultiRead<T> request,
			MultiProcedure<T> procedure) {
		session.asyncRequest(request,procedure);	
	}
	
	@Override
	public <T> void asyncRequest(MultiRead<T> request,
			SyncMultiListener<T> procedure) {
		session.asyncRequest(request,procedure);	
	}
	
	@Override
	public <T> void asyncRequest(MultiRead<T> request,
			SyncMultiProcedure<T> procedure) {
		session.asyncRequest(request,procedure);	
	}
	
	@Override
	public <T> void asyncRequest(Read<T> request) {
		session.asyncRequest(request);	
	}
	
	@Override
	public <T> void asyncRequest(Read<T> request, AsyncListener<T> procedure) {
		session.asyncRequest(request,procedure);	
	}
	
	@Override
	public <T> void asyncRequest(Read<T> request,
			AsyncProcedure<T> procedure) {
		session.asyncRequest(request,procedure);	
	}
	
	@Override
	public <T> void asyncRequest(Read<T> request, Listener<T> procedure) {
		session.asyncRequest(request,procedure);	
	}
	
	@Override
	public <T> void asyncRequest(Read<T> request, Procedure<T> procedure) {
		session.asyncRequest(request,procedure);	
	}
	
	@Override
	public <T> void asyncRequest(Read<T> request, SyncListener<T> procedure) {
		session.asyncRequest(request,procedure);	
	}
	
	@Override
	public <T> void asyncRequest(Read<T> request, SyncProcedure<T> procedure) {
		session.asyncRequest(request,procedure);	
	}
	
	@Override
	public void asyncRequest(Write request) {
		session.asyncRequest(request);	
	}
	
	@Override
	public void asyncRequest(Write request,
			Callback<DatabaseException> callback) {
		session.asyncRequest(request, callback);	
	}
	
	@Override
	public void asyncRequest(WriteOnly r) {
		session.asyncRequest(r);	
	}
	
	@Override
	public void asyncRequest(WriteOnly r,
			Callback<DatabaseException> callback) {
		session.asyncRequest(r,callback);	
	}
	
	@Override
	public <T> void asyncRequest(WriteOnlyResult<T> r,
			Procedure<T> procedure) {
		session.asyncRequest(r,procedure);	
	}
	
	@Override
	public <T> void asyncRequest(WriteResult<T> r, Procedure<T> procedure) {
		session.asyncRequest(r,procedure);	
	}
	
	
	
	@Override
	public void claim(final Resource subject, final Resource predicate,
			final Resource inverse, final Resource object) throws ServiceException {
		try {
			session.syncRequest(new WriteRequest() {
				
				@Override
				public void perform(WriteGraph graph) throws DatabaseException {
					graph.claim(subject, predicate, inverse, object);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}
	
	@Override
	public void claim(final Resource subject, final Resource predicate, final Resource object)
			throws ServiceException {
		try {
			session.syncRequest(new WriteRequest() {
				
				@Override
				public void perform(WriteGraph graph) throws DatabaseException {
					graph.claim(subject, predicate, object);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}
	

	@Override
	public void claimLiteral(final Resource resource, final Resource predicate,
			final Object value) throws ManyObjectsForFunctionalRelationException,
			ServiceException {
		try {
			session.syncRequest(new WriteRequest() {
				
				@Override
				public void perform(WriteGraph graph) throws DatabaseException {
					graph.claimLiteral(resource, predicate, value);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
		
	}
	
	@Override
	public void claimLiteral(final Resource resource, final Resource predicate,
			final Object value, final Binding binding) throws BindingException,
			ManyObjectsForFunctionalRelationException, ServiceException {
		try {
			session.syncRequest(new WriteRequest() {
				
				@Override
				public void perform(WriteGraph graph) throws DatabaseException {
					graph.claimLiteral(resource, predicate, value, binding);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
		
	}
	
	@Override
	public void claimLiteral(final Resource resource, final Resource predicate,
			final Resource inverse, final Resource type, final Object value)
			throws BindingException,
			ManyObjectsForFunctionalRelationException, ServiceException {
		try {
			session.syncRequest(new WriteRequest() {
				
				@Override
				public void perform(WriteGraph graph) throws DatabaseException {
					graph.claimLiteral(resource, predicate, inverse, type, value);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
		
	}
	
	@Override
	public void claimLiteral(final Resource resource, final Resource predicate,
			final Resource inverse, final Resource type, final Object value, final Binding binding)
			throws BindingException,
			ManyObjectsForFunctionalRelationException, ServiceException {
		try {
			session.syncRequest(new WriteRequest() {
				
				@Override
				public void perform(WriteGraph graph) throws DatabaseException {
					graph.claimLiteral(resource, predicate, inverse, type, value, binding);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
		
	}
	
	@Override
	public void claimLiteral(final Resource resource, final Resource predicate,
			final Resource type, final Object value) throws BindingException,
			ManyObjectsForFunctionalRelationException, ServiceException {
		try {
			session.syncRequest(new WriteRequest() {
				
				@Override
				public void perform(WriteGraph graph) throws DatabaseException {
					graph.claimLiteral(resource, predicate, type, value);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
		
	}
	
	@Override
	public void claimLiteral(final Resource resource, final Resource predicate,
			final Resource type, final Object value, final Binding binding)
			throws BindingException,
			ManyObjectsForFunctionalRelationException, ServiceException {
		try {
			session.syncRequest(new WriteRequest() {
				
				@Override
				public void perform(WriteGraph graph) throws DatabaseException {
					graph.claimLiteral(resource, predicate, type, value, binding);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
		
	}
	
	@Override
	public void claimValue(final Resource resource, final Object value)
			throws ServiceException {
		try {
			session.syncRequest(new WriteRequest() {
				
				@Override
				public void perform(WriteGraph graph) throws DatabaseException {
					graph.claimValue(resource, value);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
		
	}
	
	@Override
	public void claimValue(final Resource resource, final Object value, final Binding binding)
			throws ServiceException {
		try {
			session.syncRequest(new WriteRequest() {
				
				@Override
				public void perform(WriteGraph graph) throws DatabaseException {
					graph.claimValue(resource, value, binding);	
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
		
	}
	
	@SuppressWarnings("deprecation")
	@Override
	public void claimValue(final Resource resource, final Resource predicate,
			final Object value) throws ManyObjectsForFunctionalRelationException,
			ServiceException {
		try {
			session.syncRequest(new WriteRequest() {
				
				@Override
				public void perform(WriteGraph graph) throws DatabaseException {
					graph.claimValue(resource, predicate, value);	
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
		
	}
	
	@SuppressWarnings("deprecation")
	@Override
	public void claimValue(final Resource resource, final Resource predicate,
			final Object value, final Binding binding) throws BindingException,
			ManyObjectsForFunctionalRelationException, ServiceException {
		try {
			session.syncRequest(new WriteRequest() {
				
				@Override
				public void perform(WriteGraph graph) throws DatabaseException {
					graph.claimValue(resource, predicate, value, binding);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
		
	}
	
	@SuppressWarnings("deprecation")
	@Override
	public void claimValue(final Resource resource, final Resource predicate,
			final Resource inverse, final Resource type, final Object value, final Binding binding)
			throws BindingException,
			ManyObjectsForFunctionalRelationException, ServiceException {
		try {
			session.syncRequest(new WriteRequest() {
				
				@Override
				public void perform(WriteGraph graph) throws DatabaseException {
					graph.claimValue(resource, predicate, inverse, type, value, binding);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
		
	}
	
	@Override
	public void deny(final Resource subject) throws ServiceException {
		try {
			session.syncRequest(new WriteRequest() {
				
				@Override
				public void perform(WriteGraph graph) throws DatabaseException {
					graph.deny(subject);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
		
	}
	
	@Override
	public void deny(final Resource subject, final Resource predicate)
			throws ServiceException {
		try {
			session.syncRequest(new WriteRequest() {
				
				@Override
				public void perform(WriteGraph graph) throws DatabaseException {
					graph.deny(subject, predicate);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
		
	}
	
	@Override
	public void deny(final Resource subject, final Resource predicate,
			final Resource inverse, final Resource object) throws ServiceException {
		try {
			session.syncRequest(new WriteRequest() {
				
				@Override
				public void perform(WriteGraph graph) throws DatabaseException {
					graph.deny(subject, predicate, inverse, object);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
		
	}
	
	@Override
	public void deny(final Resource subject, final Resource predicate, final Resource object)
			throws ServiceException {
		try {
			session.syncRequest(new WriteRequest() {
				
				@Override
				public void perform(WriteGraph graph) throws DatabaseException {
					graph.deny(subject, predicate, object);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
		
	}
	
	@Override
	public void deny(final Statement statement) throws ServiceException {
		try {
			session.syncRequest(new WriteRequest() {
				
				@Override
				public void perform(WriteGraph graph) throws DatabaseException {
					graph.deny(statement);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
		
	}
	

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

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

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

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

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

	@Override
	public String getURI(final Resource resource)
			throws ValidationException,
			ServiceException, AssumptionException {
		try {
			return session.syncRequest(new Read<String>() {
				
				@Override
				public String perform(ReadGraph graph) throws DatabaseException {
					return graph.getURI(resource);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
		
	}

	@Override
	public String getPossibleURI(final Resource resource)
			throws ValidationException,
			ServiceException {
		try {
			return session.syncRequest(new Read<String>() {
				
				@Override
				public String perform(ReadGraph graph) throws DatabaseException {
					return graph.getPossibleURI(resource);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

	@Override
	public Resource getResource(final String uri)
			throws ResourceNotFoundException, ValidationException,
			ServiceException {
		try {
			return session.syncRequest(new Read<Resource>() {
				
				@Override
				public Resource perform(ReadGraph graph) throws DatabaseException {
					return graph.getResource(uri);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

	@Override
	public Resource getPossibleResource(final String uri)
			throws ResourceNotFoundException, ValidationException,
			ServiceException {
		try {
			return session.syncRequest(new Read<Resource>() {
				
				@Override
				public Resource perform(ReadGraph graph) throws DatabaseException {
					return graph.getPossibleResource(uri);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

	@Override
	public Collection<Statement> getStatements(final Resource subject,
			final Resource relation)
			throws ManyObjectsForFunctionalRelationException,
			ServiceException {
		try {
			return session.syncRequest(new Read<Collection<Statement>>() {
				
				@Override
				public Collection<Statement> perform(ReadGraph graph) throws DatabaseException {
					return graph.getStatements(subject, relation);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

	@Override
	public Collection<Statement> getAssertedStatements(final Resource subject,
			final Resource relation)
			throws ManyObjectsForFunctionalRelationException,
			ServiceException {
		try {
			return session.syncRequest(new Read<Collection<Statement>>() {
				
				@Override
				public Collection<Statement> perform(ReadGraph graph) throws DatabaseException {
					return graph.getAssertedStatements(subject, relation);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

	@Override
	public Collection<Resource> getPredicates(final Resource subject)
			throws ServiceException {
		try {
			return session.syncRequest(new Read<Collection<Resource>>() {
				
				@Override
				public Collection<Resource> perform(ReadGraph graph) throws DatabaseException {
					return graph.getPredicates(subject);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

	@Override
	public Collection<Resource> getPrincipalTypes(final Resource subject)
			throws ServiceException {
		try {
			return session.syncRequest(new Read<Collection<Resource>>() {
				
				@Override
				public Collection<Resource> perform(ReadGraph graph) throws DatabaseException {
					return graph.getPrincipalTypes(subject);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

	@Override
	public Set<Resource> getTypes(final Resource subject) throws ServiceException {
		try {
			return session.syncRequest(new Read<Set<Resource>>() {
				
				@Override
				public Set<Resource> perform(ReadGraph graph) throws DatabaseException {
					return graph.getTypes(subject);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

	@Override
	public Set<Resource> getSupertypes(final Resource subject)
			throws ServiceException {
		try {
			return session.syncRequest(new Read<Set<Resource>>() {
				
				@Override
				public Set<Resource> perform(ReadGraph graph) throws DatabaseException {
					return graph.getSupertypes(subject);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

	@Override
	public Set<Resource> getSuperrelations(final Resource subject)
			throws ServiceException {
		try {
			return session.syncRequest(new Read<Set<Resource>>() {
				
				@Override
				public Set<Resource> perform(ReadGraph graph) throws DatabaseException {
					return graph.getSuperrelations(subject);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

	public Resource getPossibleSuperrelation(final Resource subject) throws ServiceException {
		try {
			return session.syncRequest(new Read<Resource>() {
				@Override
				public Resource perform(ReadGraph graph) throws DatabaseException {
					return graph.getPossibleSuperrelation(subject);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

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

	@Override
	public Collection<Resource> getAssertedObjects(final Resource subject, final Resource relation)
			throws ManyObjectsForFunctionalRelationException,
			ServiceException {
		try {
			return session.syncRequest(new Read<Collection<Resource>>() {
				
				@Override
				public Collection<Resource> perform(ReadGraph graph) throws DatabaseException {
		return graph.getAssertedObjects(subject, relation);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

	@Override
	public Resource getInverse(final Resource relation)
			throws NoInverseException,
			ManyObjectsForFunctionalRelationException, ServiceException {
		try {
			return session.syncRequest(new Read<Resource>() {
				
				@Override
				public Resource perform(ReadGraph graph) throws DatabaseException {
		return graph.getInverse(relation);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

	@Override
	public Resource getSingleObject(final Resource subject, final Resource relation)
			throws NoSingleResultException,
			ManyObjectsForFunctionalRelationException, ServiceException {
		try {
			return session.syncRequest(new Read<Resource>() {
				
				@Override
				public Resource perform(ReadGraph graph) throws DatabaseException {
		return graph.getSingleObject(subject, relation);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

	@Override
	public Statement getSingleStatement(final Resource subject, final Resource relation)
			throws NoSingleResultException,
			ManyObjectsForFunctionalRelationException, ServiceException {
		try {
			return session.syncRequest(new Read<Statement>() {
				
				@Override
				public Statement perform(ReadGraph graph) throws DatabaseException {
		return graph.getSingleStatement(subject, relation);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

	@Override
	public Resource getSingleType(final Resource subject)
			throws NoSingleResultException, ServiceException {
		try {
			return session.syncRequest(new Read<Resource>() {
				
				@Override
				public Resource perform(ReadGraph graph) throws DatabaseException {
		return graph.getSingleType(subject);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

	@Override
	public Resource getSingleType(final Resource subject, final Resource baseType)
			throws NoSingleResultException, ServiceException {
		try {
			return session.syncRequest(new Read<Resource>() {
				
				@Override
				public Resource perform(ReadGraph graph) throws DatabaseException {
		return graph.getSingleType(subject, baseType);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

	@Override
	public <T> T getValue(final Resource subject)
			throws DoesNotContainValueException, ServiceException {
		try {
			return session.syncRequest(new Read<T>() {
				
				@Override
				public T perform(ReadGraph graph) throws DatabaseException {
		return graph.getValue(subject);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

	@Override
	public <T> T getValue(final Resource subject, final Binding binding)
			throws DoesNotContainValueException, BindingException,
			ServiceException {
		try {
			return session.syncRequest(new Read<T>() {
				
				@Override
				public T perform(ReadGraph graph) throws DatabaseException {
		return graph.getValue(subject, binding);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

	@Override
	public <T> T getRelatedValue(final Resource subject, final Resource relation)
			throws NoSingleResultException, DoesNotContainValueException,
			ServiceException {
		try {
			return session.syncRequest(new Read<T>() {
				
				@Override
				public T perform(ReadGraph graph) throws DatabaseException {
		return graph.getRelatedValue(subject, relation);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

	@Override
	public <T> T getRelatedValue(final Resource subject, final Resource relation,
			final Binding binding) throws NoSingleResultException,
			DoesNotContainValueException, BindingException,
			ServiceException {
		try {
			return session.syncRequest(new Read<T>() {
				
				@Override
				public T perform(ReadGraph graph) throws DatabaseException {
		return graph.getRelatedValue(subject, relation, binding);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

	@Override
	public Resource getPossibleInverse(final Resource relation)
			throws ManyObjectsForFunctionalRelationException,
			ServiceException {
		try {
			return session.syncRequest(new Read<Resource>() {
				
				@Override
				public Resource perform(ReadGraph graph) throws DatabaseException {
		return graph.getPossibleInverse(relation);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

	@Override
	public Resource getPossibleObject(final Resource subject, final Resource relation)
			throws ManyObjectsForFunctionalRelationException,
			ServiceException {
		try {
			return session.syncRequest(new Read<Resource>() {
				
				@Override
				public Resource perform(ReadGraph graph) throws DatabaseException {
		return graph.getPossibleObject(subject, relation);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

	@Override
	public Statement getPossibleStatement(final Resource subject,
			final Resource relation)
			throws ManyObjectsForFunctionalRelationException,
			ServiceException {
		try {
			return session.syncRequest(new Read<Statement>() {
				
				@Override
				public Statement perform(ReadGraph graph) throws DatabaseException {
		return graph.getPossibleStatement(subject, relation);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

	@Override
	public Resource getPossibleType(final Resource subject, final Resource baseType)
			throws ServiceException {
		try {
			return session.syncRequest(new Read<Resource>() {
				
				@Override
				public Resource perform(ReadGraph graph) throws DatabaseException {
		return graph.getPossibleType(subject, baseType);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

	@Override
	public <T> T getPossibleValue(final Resource subject) throws ServiceException {
		try {
			return session.syncRequest(new Read<T>() {
				
				@Override
				public T perform(ReadGraph graph) throws DatabaseException {
		return graph.getPossibleValue(subject);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

	@Override
	public <T> T getPossibleValue(final Resource subject, final Binding binding)
			throws BindingException, ServiceException {
		try {
			return session.syncRequest(new Read<T>() {
				
				@Override
				public T perform(ReadGraph graph) throws DatabaseException {
		return graph.getPossibleValue(subject, binding);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

	@Override
	public <T> T getPossibleRelatedValue(final Resource subject, final Resource relation)
			throws ManyObjectsForFunctionalRelationException,
			ServiceException {
		try {
			return session.syncRequest(new Read<T>() {
				
				@Override
				public T perform(ReadGraph graph) throws DatabaseException {
		return graph.getPossibleRelatedValue(subject, relation);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

	@Override
	public <T> T getPossibleRelatedValue(final Resource subject,
			final Resource relation, final Binding binding)
			throws ManyObjectsForFunctionalRelationException,
			BindingException, ServiceException {
		try {
			return session.syncRequest(new Read<T>() {
				
				@Override
				public T perform(ReadGraph graph) throws DatabaseException {
		return graph.getPossibleRelatedValue(subject, relation, binding);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

	@Override
	public <T> T getPossibleAdapter(final Resource resource, final Class<T> clazz)
			throws ValidationException, ServiceException {
		try {
			return session.syncRequest(new Read<T>() {
				
				@Override
				public T perform(ReadGraph graph) throws DatabaseException {
		return graph.getPossibleAdapter(resource, clazz);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

	@Override
	public <T> T getPossibleUniqueAdapter(final Resource resource, final Class<T> clazz)
			throws ValidationException, ServiceException {
		try {
			return session.syncRequest(new Read<T>() {
				
				@Override
				public T perform(ReadGraph graph) throws DatabaseException {
		return graph.getPossibleUniqueAdapter(resource, clazz);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

	@Override
	public boolean isInstanceOf(final Resource resource, final Resource type)
			throws ServiceException {
		try {
			return session.syncRequest(new Read<Boolean>() {
				
				@Override
				public Boolean perform(ReadGraph graph) throws DatabaseException {
					return graph.isInstanceOf(resource, type);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

	@Override
	public boolean isInheritedFrom(final Resource resource, final Resource type)
			throws ServiceException {
		try {
			return session.syncRequest(new Read<Boolean>() {
				
				@Override
				public Boolean perform(ReadGraph graph) throws DatabaseException {
		return graph.isInheritedFrom(resource, type);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

	@Override
	public boolean isSubrelationOf(final Resource resource, final Resource relation)
			throws ServiceException {
		try {
			return session.syncRequest(new Read<Boolean>() {
				
				@Override
				public Boolean perform(ReadGraph graph) throws DatabaseException {
		return graph.isSubrelationOf(resource, relation);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

	@Override
	public boolean hasStatement(final Resource subject) throws ServiceException {
		try {
			return session.syncRequest(new Read<Boolean>() {
				
				@Override
				public Boolean perform(ReadGraph graph) throws DatabaseException {
		return graph.hasStatement(subject);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

	@Override
	public boolean hasStatement(final Resource subject, final Resource relation)
			throws ServiceException {
		try {
			return session.syncRequest(new Read<Boolean>() {
				
				@Override
				public Boolean perform(ReadGraph graph) throws DatabaseException {
		return graph.hasStatement(subject, relation);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

	@Override
	public boolean hasStatement(final Resource subject, final Resource relation,
			final Resource object) throws ServiceException {
		try {
			return session.syncRequest(new Read<Boolean>() {
				
				@Override
				public Boolean perform(ReadGraph graph) throws DatabaseException {
		return graph.hasStatement(subject, relation, object);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

	@Override
	public boolean hasValue(final Resource subject) throws ServiceException {
		try {
			return session.syncRequest(new Read<Boolean>() {
				
				@Override
				public Boolean perform(ReadGraph graph) throws DatabaseException {
		return graph.hasValue(subject);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

	@Override
	public Datatype getDataType(final Resource subject) throws DatabaseException {
		try {
			return session.syncRequest(new Read<Datatype>() {
				
				@Override
				public Datatype perform(ReadGraph graph) throws DatabaseException {
		return graph.getDataType(subject);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

	@Override
	public <T extends Accessor> T getAccessor(final Resource subject)
			throws DatabaseException {
		try {
			return session.syncRequest(new Read<T>() {
				
				@Override
				public T perform(ReadGraph graph) throws DatabaseException {
		return graph.getAccessor(subject);
				}
			});
		} catch (DatabaseException e) {
			throw new ServiceException(e);
		}
	}

    @Override
    public RandomAccessBinary getRandomAccessBinary(final Resource subject)
    throws DatabaseException {
        try {
            return session.syncRequest(new Read<RandomAccessBinary>() {
                @Override
                public RandomAccessBinary perform(ReadGraph graph) throws DatabaseException {
                    return graph.getRandomAccessBinary(subject);
                }
            });
        } catch (DatabaseException e) {
            throw new ServiceException(e);
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	@Override
	public void forURI(final Resource resource, final AsyncListener<String> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forURI(resource, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forURI(final Resource resource, final SyncListener<String> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forURI(resource, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forURI(final Resource resource, final Listener<String> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forURI(resource, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forURI(final Resource resource, final AsyncProcedure<String> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forURI(resource, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forURI(final Resource resource, final SyncProcedure<String> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forURI(resource, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forURI(final Resource resource, final Procedure<String> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forURI(resource, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forResource(final String id, final AsyncListener<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forResource(id, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forResource(final String id, final SyncListener<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forResource(id, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forResource(final String id, final Listener<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forResource(id, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forResource(final String id, final AsyncProcedure<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forResource(id, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forResource(final String id, final SyncProcedure<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forResource(id, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forResource(final String id, final Procedure<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forResource(id, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forStatementSet(final Resource subject, final Resource relation,
			final AsyncSetListener<Statement> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forStatementSet(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forStatementSet(final Resource subject, final Resource relation,
			final SyncSetListener<Statement> procedure) {
		
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
					graph.forStatementSet(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forStatementSet(final Resource subject, final Resource relation,
			final SetListener<Statement> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forStatementSet(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forPredicateSet(final Resource subject,
			final AsyncSetListener<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPredicateSet(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forPredicateSet(final Resource subject,
			final SyncSetListener<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPredicateSet(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forPredicateSet(final Resource subject,
			final SetListener<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPredicateSet(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forPrincipalTypeSet(final Resource subject,
			final AsyncSetListener<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPrincipalTypeSet(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forPrincipalTypeSet(final Resource subject,
			final SyncSetListener<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
					graph.forPrincipalTypeSet(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forPrincipalTypeSet(final Resource subject,
			final SetListener<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPrincipalTypeSet(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forTypes(final Resource subject,
			final AsyncListener<Set<Resource>> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forTypes(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forTypes(final Resource subject,
			final SyncListener<Set<Resource>> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forTypes(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forTypes(final Resource subject, final Listener<Set<Resource>> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forTypes(subject, procedure);		
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forTypes(final Resource subject,
			final AsyncProcedure<Set<Resource>> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forTypes(subject, procedure);		
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forTypes(final Resource subject,
			final SyncProcedure<Set<Resource>> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forTypes(subject, procedure);		
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forTypes(final Resource subject,
			final Procedure<Set<Resource>> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forTypes(subject, procedure);	
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forSupertypes(final Resource subject,
			final AsyncListener<Set<Resource>> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forSupertypes(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forSupertypes(final Resource subject,
			final SyncListener<Set<Resource>> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forSupertypes(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forSupertypes(final Resource subject,
			final Listener<Set<Resource>> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forSupertypes(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forSupertypes(final Resource subject,
			final AsyncProcedure<Set<Resource>> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forSupertypes(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forSupertypes(final Resource subject,
			final SyncProcedure<Set<Resource>> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forSupertypes(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forSupertypes(final Resource subject,
			final Procedure<Set<Resource>> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forSupertypes(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forPossibleSuperrelation(final Resource subject,
			final AsyncProcedure<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleSuperrelation(subject, procedure);	
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forSuperrelations(final Resource subject,
			final AsyncListener<Set<Resource>> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forSuperrelations(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forSuperrelations(final Resource subject,
			final SyncListener<Set<Resource>> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forSuperrelations(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forSuperrelations(final Resource subject,
			final Listener<Set<Resource>> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forSuperrelations(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forSuperrelations(final Resource subject,
			final AsyncProcedure<Set<Resource>> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forSuperrelations(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forSuperrelations(final Resource subject,
			final SyncProcedure<Set<Resource>> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forSuperrelations(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forSuperrelations(final Resource subject,
			final Procedure<Set<Resource>> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forSuperrelations(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forObjectSet(final Resource subject, final Resource relation,
			final AsyncSetListener<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forObjectSet(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forObjectSet(final Resource subject, final Resource relation,
			final SyncSetListener<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forObjectSet(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forObjectSet(final Resource subject, final Resource relation,
			final SetListener<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forObjectSet(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forInverse(final Resource relation,
			final SyncListener<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forInverse(relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forInverse(final Resource relation, final Listener<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forInverse(relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forInverse(final Resource relation,
			final AsyncProcedure<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forInverse(relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forInverse(final Resource relation,
			final SyncProcedure<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forInverse(relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forInverse(final Resource relation, final Procedure<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forInverse(relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forSingleObject(final Resource subject, final Resource relation,
			final AsyncListener<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forSingleObject(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forSingleObject(final Resource subject, final Resource relation,
			final SyncListener<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forSingleObject(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forSingleObject(final Resource subject, final Resource relation,
			final Listener<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forSingleObject(subject, relation, procedure);		
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forSingleObject(final Resource subject, final Resource relation,
			final AsyncProcedure<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forSingleObject(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forSingleObject(final Resource subject, final Resource relation,
			final SyncProcedure<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forSingleObject(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forSingleObject(final Resource subject, final Resource relation,
			final Procedure<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forSingleObject(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forSingleStatement(final Resource subject, final Resource relation,
			final AsyncListener<Statement> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forSingleStatement(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forSingleStatement(final Resource subject, final Resource relation,
			final SyncListener<Statement> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forSingleStatement(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forSingleStatement(final Resource subject, final Resource relation,
			final Listener<Statement> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
					graph.forSingleStatement(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
				
	}

	@Override
	public void forSingleStatement(final Resource subject, final Resource relation,
			final AsyncProcedure<Statement> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forSingleStatement(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forSingleStatement(final Resource subject, final Resource relation,
			final SyncProcedure<Statement> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forSingleStatement(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forSingleStatement(final Resource subject, final Resource relation,
			final Procedure<Statement> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forSingleStatement(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forSingleType(final Resource subject,
			final AsyncListener<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forSingleType(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forSingleType(final Resource subject,
			final SyncListener<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forSingleType(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forSingleType(final Resource subject, final Listener<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forSingleType(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forSingleType(final Resource subject,
			final AsyncProcedure<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forSingleType(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forSingleType(final Resource subject,
			final SyncProcedure<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forSingleType(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forSingleType(final Resource subject,
			final Procedure<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forSingleType(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forSingleType(final Resource subject, final Resource baseType,
			final AsyncListener<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forSingleType(subject, baseType, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forSingleType(final Resource subject, final Resource baseType,
			final SyncListener<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forSingleType(subject, baseType, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forSingleType(final Resource subject, final Resource baseType,
			final Listener<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forSingleType(subject, baseType, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forSingleType(final Resource subject, final Resource baseType,
			final AsyncProcedure<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forSingleType(subject, baseType, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forSingleType(final Resource subject, final Resource baseType,
			final SyncProcedure<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forSingleType(subject, baseType, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forSingleType(final Resource subject, final Resource baseType,
			final Procedure<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forSingleType(subject, baseType, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forValue(final Resource subject, final AsyncListener<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forValue(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forValue(final Resource subject, final SyncListener<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forValue(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forValue(final Resource subject, final Listener<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forValue(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forValue(final Resource subject, final AsyncProcedure<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forValue(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forValue(final Resource subject, final SyncProcedure<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forValue(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forValue(final Resource subject, final Procedure<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forValue(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forValue(final Resource subject, final Binding binding,
			final AsyncListener<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forValue(subject, binding, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forValue(final Resource subject, final Binding binding,
			final SyncListener<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forValue(subject, binding, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forValue(final Resource subject, final Binding binding,
			final Listener<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forValue(subject, binding, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forValue(final Resource subject, final Binding binding,
			final AsyncProcedure<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forValue(subject, binding, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forValue(final Resource subject, final Binding binding,
			final SyncProcedure<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forValue(subject, binding, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forValue(final Resource subject, final Binding binding,
			final Procedure<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forValue(subject, binding, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forRelatedValue(final Resource subject, final Resource relation,
			final AsyncListener<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forRelatedValue(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forRelatedValue(final Resource subject, final Resource relation,
			final SyncListener<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forRelatedValue(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forRelatedValue(final Resource subject, final Resource relation,
			final Listener<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forRelatedValue(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forRelatedValue(final Resource subject, final Resource relation,
			final AsyncProcedure<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forRelatedValue(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forRelatedValue(final Resource subject, final Resource relation,
			final SyncProcedure<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forRelatedValue(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forRelatedValue(final Resource subject, final Resource relation,
			final Procedure<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forRelatedValue(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forRelatedValue(final Resource subject, final Resource relation,
			final Binding binding, final AsyncListener<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forRelatedValue(subject, relation, binding, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forRelatedValue(final Resource subject, final Resource relation,
			final Binding binding, final SyncListener<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forRelatedValue(subject, relation, binding, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forRelatedValue(final Resource subject, final Resource relation,
			final Binding binding, final Listener<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forRelatedValue(subject, relation, binding, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forRelatedValue(final Resource subject, final Resource relation,
			final Binding binding, final AsyncProcedure<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forRelatedValue(subject, relation, binding, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forRelatedValue(final Resource subject, final Resource relation,
			final Binding binding, final SyncProcedure<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forRelatedValue(subject, relation, binding, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forRelatedValue(final Resource subject, final Resource relation,
			final Binding binding, final Procedure<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forRelatedValue(subject, relation, binding, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forUniqueAdapted(final Resource resource, final Class<T> clazz,
			final AsyncListener<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forUniqueAdapted(resource, clazz, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forUniqueAdapted(final Resource resource, final Class<T> clazz,
			final SyncListener<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forUniqueAdapted(resource, clazz, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forUniqueAdapted(final Resource resource, final Class<T> clazz,
			final Listener<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forUniqueAdapted(resource, clazz, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forUniqueAdapted(final Resource resource, final Class<T> clazz,
			final AsyncProcedure<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forUniqueAdapted(resource, clazz, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forUniqueAdapted(final Resource resource, final Class<T> clazz,
			final SyncProcedure<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forUniqueAdapted(resource, clazz, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forUniqueAdapted(final Resource resource, final Class<T> clazz,
			final Procedure<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forUniqueAdapted(resource, clazz, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forPossibleInverse(final Resource relation,
			final AsyncListener<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleInverse(relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forPossibleInverse(final Resource relation,
			final SyncListener<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleInverse(relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forPossibleInverse(final Resource relation,
			final Listener<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleInverse(relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forPossibleInverse(final Resource relation,
			final AsyncProcedure<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleInverse(relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forPossibleInverse(final Resource relation,
			final SyncProcedure<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleInverse(relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forPossibleInverse(final Resource relation,
			final Procedure<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleInverse(relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forPossibleObject(final Resource subject, final Resource relation,
			final AsyncListener<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleObject(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forPossibleObject(final Resource subject, final Resource relation,
			final SyncListener<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleObject(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forPossibleObject(final Resource subject, final Resource relation,
			final Listener<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleObject(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forPossibleObject(final Resource subject, final Resource relation,
			final AsyncProcedure<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleObject(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forPossibleObject(final Resource subject, final Resource relation,
			final SyncProcedure<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleObject(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forPossibleObject(final Resource subject, final Resource relation,
			final Procedure<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleObject(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forPossibleStatement(final Resource subject, final Resource relation,
			final AsyncListener<Statement> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleStatement(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forPossibleStatement(final Resource subject, final Resource relation,
			final SyncListener<Statement> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleStatement(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forPossibleStatement(final Resource subject, final Resource relation,
			final Listener<Statement> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleStatement(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forPossibleStatement(final Resource subject, final Resource relation,
			final AsyncProcedure<Statement> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleStatement(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forPossibleStatement(final Resource subject, final Resource relation,
			final SyncProcedure<Statement> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleStatement(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forPossibleStatement(final Resource subject, final Resource relation,
			final Procedure<Statement> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleStatement(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forPossibleType(final Resource subject, final Resource baseType,
			final AsyncListener<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleType(subject, baseType, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forPossibleType(final Resource subject, final Resource baseType,
			final SyncListener<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleType(subject, baseType, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forPossibleType(final Resource subject, final Resource baseType,
			final Listener<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleType(subject, baseType, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forPossibleType(final Resource subject, final Resource baseType,
			final AsyncProcedure<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleType(subject, baseType, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forPossibleType(final Resource subject, final Resource baseType,
			final SyncProcedure<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleType(subject, baseType, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forPossibleType(final Resource subject, final Resource baseType,
			final Procedure<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleType(subject, baseType, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forPossibleValue(final Resource subject,
			final AsyncListener<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleValue(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forPossibleValue(final Resource subject,
			final SyncListener<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleValue(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forPossibleValue(final Resource subject, final Listener<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleValue(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forPossibleValue(final Resource subject,
			final AsyncProcedure<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleValue(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forPossibleValue(final Resource subject,
			final SyncProcedure<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleValue(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forPossibleValue(final Resource subject,
			final Procedure<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleValue(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forPossibleValue(final Resource subject, final Binding binding,
			final AsyncListener<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleValue(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forPossibleValue(final Resource subject, final Binding binding,
			final SyncListener<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleValue(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forPossibleValue(final Resource subject, final Binding binding,
			final Listener<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleValue(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forPossibleValue(final Resource subject, final Binding binding,
			final AsyncProcedure<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleValue(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forPossibleValue(final Resource subject, final Binding binding,
			final SyncProcedure<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleValue(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forPossibleValue(final Resource subject, final Binding binding,
			final Procedure<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleValue(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forPossibleRelatedValue(final Resource subject,
			final Resource relation, final AsyncListener<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleRelatedValue(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forPossibleRelatedValue(final Resource subject,
			final Resource relation, final SyncListener<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleRelatedValue(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forPossibleRelatedValue(final Resource subject,
			final Resource relation, final Listener<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleRelatedValue(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forPossibleRelatedValue(final Resource subject,
			final Resource relation, final AsyncProcedure<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleRelatedValue(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forPossibleRelatedValue(final Resource subject,
			final Resource relation, final SyncProcedure<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleRelatedValue(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forPossibleRelatedValue(final Resource subject,
			final Resource relation, final Procedure<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleRelatedValue(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forPossibleRelatedValue(final Resource subject,
			final Resource relation, final Binding binding, final AsyncListener<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleRelatedValue(subject, relation, binding, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forPossibleRelatedValue(final Resource subject,
			final Resource relation, final Binding binding, final SyncListener<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleRelatedValue(subject, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forPossibleRelatedValue(final Resource subject,
			final Resource relation, final Binding binding, final Listener<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleRelatedValue(subject, relation, binding, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forPossibleRelatedValue(final Resource subject,
			final Resource relation, final Binding binding, final AsyncProcedure<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleRelatedValue(subject, relation, binding, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forPossibleRelatedValue(final Resource subject,
			final Resource relation, final Binding binding, final SyncProcedure<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleRelatedValue(subject, relation, binding, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forPossibleRelatedValue(final Resource subject,
			final Resource relation, final Binding binding, final Procedure<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleRelatedValue(subject, relation, binding, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forPossibleAdapted(final Resource resource, final Class<T> clazz,
			final AsyncListener<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleAdapted(resource, clazz, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forPossibleAdapted(final Resource resource, final Class<T> clazz,
			final SyncListener<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleAdapted(resource, clazz, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forPossibleAdapted(final Resource resource, final Class<T> clazz,
			final Listener<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleAdapted(resource, clazz, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forPossibleAdapted(final Resource resource, final Class<T> clazz,
			final AsyncProcedure<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleAdapted(resource, clazz, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forPossibleAdapted(final Resource resource, final Class<T> clazz,
			final SyncProcedure<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleAdapted(resource, clazz, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forPossibleAdapted(final Resource resource, final Class<T> clazz,
			final Procedure<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleAdapted(resource, clazz, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forPossibleUniqueAdapted(final Resource resource,
			final Class<T> clazz, final AsyncListener<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleUniqueAdapted(resource, clazz, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forPossibleUniqueAdapted(final Resource resource,
			final Class<T> clazz, final SyncListener<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleUniqueAdapted(resource, clazz, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forPossibleUniqueAdapted(final Resource resource,
			final Class<T> clazz, final Listener<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleUniqueAdapted(resource, clazz, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forPossibleUniqueAdapted(final Resource resource,
			final Class<T> clazz, final AsyncProcedure<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleUniqueAdapted(resource, clazz, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forPossibleUniqueAdapted(final Resource resource,
			final Class<T> clazz, final SyncProcedure<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleUniqueAdapted(resource, clazz, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public <T> void forPossibleUniqueAdapted(final Resource resource,
			final Class<T> clazz, final Procedure<T> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forPossibleUniqueAdapted(resource, clazz, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forIsInstanceOf(final Resource resource, final Resource type,
			final AsyncListener<Boolean> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forIsInstanceOf(resource, type, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forIsInstanceOf(final Resource resource, final Resource type,
			final SyncListener<Boolean> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forIsInstanceOf(resource, type, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forIsInstanceOf(final Resource resource, final Resource type,
			final Listener<Boolean> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forIsInstanceOf(resource, type, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forIsInstanceOf(final Resource resource, final Resource type,
			final AsyncProcedure<Boolean> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forIsInstanceOf(resource, type, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forIsInstanceOf(final Resource resource, final Resource type,
			final SyncProcedure<Boolean> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forIsInstanceOf(resource, type, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forIsInstanceOf(final Resource resource, final Resource type,
			final Procedure<Boolean> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forIsInstanceOf(resource, type, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forIsInheritedFrom(final Resource resource, final Resource type,
			final AsyncListener<Boolean> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forIsInheritedFrom(resource, type, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forIsInheritedFrom(final Resource resource, final Resource type,
			final SyncListener<Boolean> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forIsInheritedFrom(resource, type, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forIsInheritedFrom(final Resource resource, final Resource type,
			final Listener<Boolean> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forIsInheritedFrom(resource, type, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forIsInheritedFrom(final Resource resource, final Resource type,
			final AsyncProcedure<Boolean> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forIsInheritedFrom(resource, type, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forIsInheritedFrom(final Resource resource, final Resource type,
			final SyncProcedure<Boolean> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forIsInheritedFrom(resource, type, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forIsInheritedFrom(final Resource resource, final Resource type,
			final Procedure<Boolean> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forIsInheritedFrom(resource, type, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forIsSubrelationOf(final Resource resource, final Resource relation,
			final AsyncListener<Boolean> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forIsSubrelationOf(resource, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forIsSubrelationOf(final Resource resource, final Resource relation,
			final SyncListener<Boolean> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forIsSubrelationOf(resource, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forIsSubrelationOf(final Resource resource, final Resource relation,
			final Listener<Boolean> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forIsSubrelationOf(resource, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forIsSubrelationOf(final Resource resource, final Resource relation,
			final AsyncProcedure<Boolean> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forIsSubrelationOf(resource, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forIsSubrelationOf(final Resource resource, final Resource relation,
			final SyncProcedure<Boolean> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forIsSubrelationOf(resource, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forIsSubrelationOf(final Resource resource, final Resource relation,
			final Procedure<Boolean> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forIsSubrelationOf(resource, relation, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forOrderedSet(final Resource subject,
			final AsyncMultiListener<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forOrderedSet(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forOrderedSet(final Resource subject,
			final SyncMultiListener<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forOrderedSet(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forOrderedSet(final Resource subject,
			final MultiListener<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forOrderedSet(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forOrderedSet(final Resource subject,
			final AsyncMultiProcedure<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forOrderedSet(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forOrderedSet(final Resource subject,
			final SyncMultiProcedure<Resource> procedure) {
		
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
					graph.forOrderedSet(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public void forOrderedSet(final Resource subject,
			final MultiProcedure<Resource> procedure) {
		try {
			session.syncRequest(new ReadRequest() {
				
				@Override
				public void run(ReadGraph graph) throws DatabaseException {
		graph.forOrderedSet(subject, procedure);
				}
			});
		} catch (DatabaseException e) {
			
		}
	}

	@Override
	public int thread() {
		return -1;
	}

	@Override
	public Session getSession() {
		return session;
	}

	@Override
	public Resource getBuiltin(final String id) throws ResourceNotFoundException,
			ServiceException {
		try {
			return session.syncRequest(new Read<Resource>() {
				
				@Override
				public Resource perform(ReadGraph graph) throws DatabaseException {
					return graph.getBuiltin(id);
				}
				});
			} catch (DatabaseException e) {
				throw new ServiceException(e);
			}
	}
	
	@Override
	public VirtualGraph getProvider() {
		return null;
	}

	@Override
	public boolean isImmutable(final Resource resource) throws DatabaseException {
	    try {
	        return session.syncRequest(new Read<Boolean>() {
	            @Override
	            public Boolean perform(ReadGraph graph) throws DatabaseException {
	                return graph.isImmutable(resource);
	            }
	        });
	    } catch (DatabaseException e) {
	        throw new ServiceException(e);
	    }
	}

}