ForwardingTripleTransaction.java

package eu.fbk.knowledgestore.triplestore;

import java.io.IOException;

import javax.annotation.Nullable;

import com.google.common.collect.ForwardingObject;

import org.openrdf.model.Resource;
import org.openrdf.model.Statement;
import org.openrdf.model.URI;
import org.openrdf.model.Value;
import org.openrdf.query.BindingSet;
import org.openrdf.query.QueryEvaluationException;

import info.aduna.iteration.CloseableIteration;

import eu.fbk.knowledgestore.data.Handler;

/**
 * A <tt>TripleTransaction</tt> that forwards all its method calls to another
 * <tt>TripleTransaction</tt>.
 * <p>
 * This class provides a starting point for implementing the decorator pattern on top of the
 * <tt>TripleTransaction</tt> interface. Subclasses must implement method {@link #delegate()} and
 * override the methods of <tt>TripleTransaction</tt> they want to decorate.
 * </p>
 */
public abstract class ForwardingTripleTransaction extends ForwardingObject implements
        TripleTransaction {

    @Override
    protected abstract TripleTransaction delegate();

    @Override
    public CloseableIteration<? extends Statement, ? extends Exception> get(
            @Nullable final Resource subject, @Nullable final URI predicate,
            @Nullable final Value object, @Nullable final Resource context) throws IOException,
            IllegalStateException {
        return delegate().get(subject, predicate, object, context);
    }

    @Override
    public CloseableIteration<BindingSet, QueryEvaluationException> query(final SelectQuery query,
            @Nullable final BindingSet bindings, @Nullable final Long timeout) throws IOException,
            UnsupportedOperationException {
        return delegate().query(query, bindings, timeout);
    }

    @Override
    public void infer(@Nullable final Handler<? super Statement> handler) throws IOException,
            IllegalStateException {
        delegate().infer(handler);
    }

    @Override
    public void add(final Iterable<? extends Statement> statements) throws IOException,
            IllegalStateException {
        delegate().add(statements);
    }

    @Override
    public void remove(final Iterable<? extends Statement> statements) throws IOException,
            IllegalStateException {
        delegate().remove(statements);
    }

    @Override
    public void end(final boolean commit) throws IOException {
        delegate().end(commit);
    }

}