/*******************************************************************************
 * Copyright (c) 2007, 2018 Association for Decentralized Information Management
 * in Industry THTH ry.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     VTT Technical Research Centre of Finland - initial API and implementation
 *******************************************************************************/
package org.simantics.db.common.processor;

import java.util.Collection;
import java.util.function.Consumer;

import org.simantics.db.AsyncRequestProcessor;
import org.simantics.db.Resource;
import org.simantics.db.Session;
import org.simantics.db.exception.DatabaseException;
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.Listener;
import org.simantics.db.procedure.MultiListener;
import org.simantics.db.procedure.MultiProcedure;
import org.simantics.db.procedure.Procedure;
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.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;

public class ProcessorBase implements AsyncRequestProcessor {

    @Override
    public <T> T l0() {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> void asyncRequest(AsyncMultiRead<T> request, AsyncMultiProcedure<T> procedure) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> void asyncRequest(AsyncRead<T> request, AsyncProcedure<T> procedure) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void asyncRequest(Write request, Consumer<DatabaseException> callback) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void asyncRequest(DelayedWrite request, Consumer<DatabaseException> callback) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void asyncRequest(WriteOnly request, Consumer<DatabaseException> callback) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> Collection<T> syncRequest(AsyncMultiRead<T> request, final AsyncMultiProcedure<T> procedure) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> T syncRequest(AsyncRead<T> request, final AsyncProcedure<T> procedure) {
        throw new UnsupportedOperationException();
    }


    @Override
    public void syncRequest(Write request) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void syncRequest(WriteOnly request) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Session getSession() {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> void asyncRequest(AsyncRead<T> request) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> void asyncRequest(AsyncRead<T> request,
            Procedure<T> procedure) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> void asyncRequest(AsyncMultiRead<T> request) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> void asyncRequest(AsyncMultiRead<T> request,
            MultiProcedure<T> procedure) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> T syncRequest(AsyncRead<T> request) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> T syncRequest(AsyncRead<T> request,
            Procedure<T> procedure) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> Collection<T> syncRequest(AsyncMultiRead<T> request) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
            MultiProcedure<T> procedure) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> T syncRequest(Read<T> request) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> T syncRequest(Read<T> request,
            final AsyncProcedure<T> procedure) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> void asyncRequest(Read<T> request) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> void asyncRequest(Read<T> request,
            AsyncProcedure<T> procedure) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> T syncRequest(Read<T> request, Procedure<T> procedure) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> Collection<T> syncRequest(final MultiRead<T> request) throws DatabaseException {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> Collection<T> syncRequest(MultiRead<T> request, MultiProcedure<T> procedure) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> void asyncRequest(Read<T> request, Procedure<T> procedure) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> void asyncRequest(MultiRead<T> request) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> void asyncRequest(MultiRead<T> request, MultiProcedure<T> procedure) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void asyncRequest(Write r) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void asyncRequest(WriteOnly r) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> T getService(Class<T> api) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> T peekService(Class<T> api) {
        throw new UnsupportedOperationException();
    }

    @Override
    public boolean hasService(Class<?> api) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> void registerService(Class<T> api, T service) {
        throw new UnsupportedOperationException();
    }

//    @Override
//    public <T> T syncRequest(Read<T> arg0, AsyncListener<T> arg1) {
//        throw new UnsupportedOperationException();
//    }

    @Override
    public <T> T syncRequest(Read<T> arg0, SyncListener<T> arg1) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> T syncRequest(Read<T> arg0, Listener<T> arg1) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> T syncRequest(Read<T> arg0, SyncProcedure<T> arg1) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> T syncRequest(AsyncRead<T> arg0, AsyncListener<T> arg1) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> T syncRequest(AsyncRead<T> arg0, SyncListener<T> arg1) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> T syncRequest(AsyncRead<T> arg0, Listener<T> arg1) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> T syncRequest(AsyncRead<T> arg0, SyncProcedure<T> arg1) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> void asyncRequest(Read<T> arg0, AsyncListener<T> arg1) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> void asyncRequest(Read<T> arg0, SyncListener<T> arg1) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> void asyncRequest(Read<T> arg0, Listener<T> arg1) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> void asyncRequest(Read<T> arg0, SyncProcedure<T> arg1) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> void asyncRequest(AsyncRead<T> arg0, AsyncListener<T> arg1) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> void asyncRequest(AsyncRead<T> arg0, SyncListener<T> arg1) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> void asyncRequest(AsyncRead<T> arg0, Listener<T> arg1) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> void asyncRequest(AsyncRead<T> arg0, SyncProcedure<T> arg1) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> Collection<T> syncRequest(MultiRead<T> arg0, SyncMultiListener<T> arg1) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> Collection<T> syncRequest(MultiRead<T> arg0, MultiListener<T> arg1) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> Collection<T> syncRequest(MultiRead<T> arg0, SyncMultiProcedure<T> arg1) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> Collection<T> syncRequest(AsyncMultiRead<T> arg0,
            AsyncMultiListener<T> arg1) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> Collection<T> syncRequest(AsyncMultiRead<T> arg0, SyncMultiListener<T> arg1) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> Collection<T> syncRequest(AsyncMultiRead<T> arg0,
            MultiListener<T> arg1) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> Collection<T> syncRequest(AsyncMultiRead<T> arg0, SyncMultiProcedure<T> arg1) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> void asyncRequest(MultiRead<T> arg0, SyncMultiListener<T> arg1) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> void asyncRequest(MultiRead<T> arg0, MultiListener<T> arg1) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> void asyncRequest(MultiRead<T> arg0, SyncMultiProcedure<T> arg1) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> void asyncRequest(AsyncMultiRead<T> arg0,
            AsyncMultiListener<T> arg1) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> void asyncRequest(AsyncMultiRead<T> arg0, SyncMultiListener<T> arg1) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> void asyncRequest(AsyncMultiRead<T> arg0,
            MultiListener<T> arg1) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> void asyncRequest(AsyncMultiRead<T> arg0, SyncMultiProcedure<T> arg1) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> void asyncRequest(ExternalRead<T> request, Procedure<T> procedure) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> T syncRequest(ExternalRead<T> request) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> T syncRequest(ExternalRead<T> request, Listener<T> procedure) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> T syncRequest(ExternalRead<T> request, Procedure<T> procedure) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> void asyncRequest(ExternalRead<T> request) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> void asyncRequest(ExternalRead<T> request, Listener<T> procedure) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void syncRequest(DelayedWrite request) throws DatabaseException {
        throw new UnsupportedOperationException();
    }

    @Override
    public void asyncRequest(DelayedWrite request) {
        throw new UnsupportedOperationException();
    }

	@Override
	public <T> T syncRequest(WriteResult<T> request) throws DatabaseException {
		throw new UnsupportedOperationException();
	}

	@Override
	public <T> T syncRequest(DelayedWriteResult<T> request)
			throws DatabaseException {
		throw new UnsupportedOperationException();
	}

	@Override
	public <T> T syncRequest(WriteOnlyResult<T> r) throws DatabaseException {
		throw new UnsupportedOperationException();
	}

	@Override
	public <T> void asyncRequest(WriteResult<T> r, Procedure<T> procedure) {
		throw new UnsupportedOperationException();
	}

	@Override
	public <T> void asyncRequest(DelayedWriteResult<T> r, Procedure<T> procedure) {
		throw new UnsupportedOperationException();
	}

	@Override
	public <T> void asyncRequest(WriteOnlyResult<T> r, Procedure<T> procedure) {
		throw new UnsupportedOperationException();
	}
	
	@Override
	public Resource getRootLibrary() {
		throw new UnsupportedOperationException();
	}

	@Override
	public <T> void async(ReadInterface<T> r, Procedure<T> procedure) {
		throw new UnsupportedOperationException();
	}

	@Override
	public <T> void async(ReadInterface<T> r, AsyncProcedure<T> procedure) {
		throw new UnsupportedOperationException();
	}

	@Override
	public <T> void async(ReadInterface<T> r, SyncProcedure<T> procedure) {
		throw new UnsupportedOperationException();
	}

	@Override
	public <T> void async(ReadInterface<T> r, Listener<T> procedure) {
		throw new UnsupportedOperationException();
	}

	@Override
	public <T> void async(ReadInterface<T> r, AsyncListener<T> procedure) {
		throw new UnsupportedOperationException();
	}

	@Override
	public <T> void async(ReadInterface<T> r, SyncListener<T> procedure) {
		throw new UnsupportedOperationException();
	}

	@Override
	public <T> T sync(ReadInterface<T> r) throws DatabaseException {
		throw new UnsupportedOperationException();
	}

	@Override
	public <T> T sync(WriteInterface<T> r) throws DatabaseException {
		throw new UnsupportedOperationException();
	}
	
	@Override
	public <T> void async(WriteInterface<T> r, Procedure<T> procedure) {
		throw new UnsupportedOperationException();
	}

	@Override
	public <T> void async(WriteInterface<T> r) {
		throw new UnsupportedOperationException();
	}
	
	@Override
	public Object getModificationCounter() {
		throw new UnsupportedOperationException();
	}
	
}