io.jsync.impl.CountingCompletionHandler Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of jsync.io Show documentation

jsync.io is a non-blocking, event-driven networking framework for Java

There is a newer version: 1.10.13

/*
 * Copyright (c) 2011-2013 The original author or authors
 * ------------------------------------------------------
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * and Apache License v2.0 which accompanies this distribution.
 *
 *     The Eclipse Public License is available at
 *     http://www.eclipse.org/legal/epl-v10.html
 *
 *     The Apache License v2.0 is available at
 *     http://www.opensource.org/licenses/apache2.0.php
 *
 * You may elect to redistribute this code under either of these licenses.
 */

package io.jsync.impl;

import io.jsync.AsyncResult;
import io.jsync.Handler;

/**
 * @author Tim Fox
 */
public class CountingCompletionHandler {

    private final DefaultContext context;
    private final AsyncInternal async;
    private int count;
    private int required;
    private Handler> doneHandler;
    private Throwable cause;
    private boolean failed;

    public CountingCompletionHandler(AsyncInternal async) {
        this(async, 0);
    }

    public CountingCompletionHandler(AsyncInternal async, int required) {
        this.async = async;
        this.context = async.getOrCreateContext();
        this.required = required;
    }

    public synchronized void complete() {
        count++;
        checkDone();
    }

    public synchronized void failed(Throwable t) {
        if (!failed) {
            // Fail immediately - but only once
            if (doneHandler != null) {
                callHandler(new DefaultFutureResult(t));
            } else {
                cause = t;
            }
            failed = true;
        }
    }

    public synchronized void incRequired() {
        required++;
    }

    public synchronized void setHandler(Handler> doneHandler) {
        this.doneHandler = doneHandler;
        checkDone();
    }

    private void callHandler(final AsyncResult result) {
        if (async.getContext() == context) {
            doneHandler.handle(result);
        } else {
            context.execute(new Runnable() {
                public void run() {
                    doneHandler.handle(result);
                }
            });
        }
    }


    void checkDone() {
        if (doneHandler != null) {
            if (cause != null) {
                callHandler(new DefaultFutureResult(cause));
            } else {
                if (count == required) {
                    final DefaultFutureResult res = new DefaultFutureResult((T) null);
                    callHandler(res);
                }
            }
        }
    }
}