// Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/kpdus/jad.html
// Decompiler options: braces fieldsfirst space lnc 

package org.jdeferred.impl;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import org.jdeferred.DeferredCallable;
import org.jdeferred.DeferredFutureTask;
import org.jdeferred.DeferredManager;
import org.jdeferred.DeferredRunnable;
import org.jdeferred.Promise;
import org.jdeferred.multiple.MasterDeferredObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public abstract class AbstractDeferredManager
    implements DeferredManager
{

    protected final Logger log = LoggerFactory.getLogger(org/jdeferred/impl/AbstractDeferredManager);

    public AbstractDeferredManager()
    {
    }

    protected void assertNotEmpty(Object aobj[])
    {
        if (aobj == null || aobj.length == 0)
        {
            throw new IllegalArgumentException("Arguments is null or its length is empty");
        } else
        {
            return;
        }
    }

    public abstract boolean isAutoSubmit();

    protected abstract void submit(Runnable runnable);

    protected abstract void submit(Callable callable);

    public Promise when(Runnable runnable)
    {
        return when(new DeferredFutureTask(runnable));
    }

    public Promise when(Callable callable)
    {
        return when(new DeferredFutureTask(callable));
    }

    public Promise when(Future future)
    {
        return when(((DeferredCallable) (new DeferredCallable(future) {

            final AbstractDeferredManager this$0;
            final Future val$future;

            public Object call()
                throws Exception
            {
                Object obj;
                try
                {
                    obj = future.get();
                }
                catch (InterruptedException interruptedexception)
                {
                    throw interruptedexception;
                }
                catch (ExecutionException executionexception)
                {
                    if (executionexception.getCause() instanceof Exception)
                    {
                        throw (Exception)executionexception.getCause();
                    } else
                    {
                        throw executionexception;
                    }
                }
                return obj;
            }

            
            {
                this$0 = AbstractDeferredManager.this;
                future = future1;
                super(final_startpolicy);
            }
        })));
    }

    public Promise when(DeferredCallable deferredcallable)
    {
        return when(new DeferredFutureTask(deferredcallable));
    }

    public Promise when(DeferredFutureTask deferredfuturetask)
    {
        if (deferredfuturetask.getStartPolicy() == org.jdeferred.DeferredManager.StartPolicy.AUTO || deferredfuturetask.getStartPolicy() == org.jdeferred.DeferredManager.StartPolicy.DEFAULT && isAutoSubmit())
        {
            submit(deferredfuturetask);
        }
        return deferredfuturetask.promise();
    }

    public Promise when(DeferredRunnable deferredrunnable)
    {
        return when(new DeferredFutureTask(deferredrunnable));
    }

    public Promise when(Promise promise)
    {
        return promise;
    }

    public transient Promise when(Runnable arunnable[])
    {
        assertNotEmpty(arunnable);
        Promise apromise[] = new Promise[arunnable.length];
        int i = 0;
        while (i < arunnable.length) 
        {
            if (arunnable[i] instanceof DeferredRunnable)
            {
                apromise[i] = when((DeferredRunnable)arunnable[i]);
            } else
            {
                apromise[i] = when(arunnable[i]);
            }
            i++;
        }
        return when(apromise);
    }

    public transient Promise when(Callable acallable[])
    {
        assertNotEmpty(acallable);
        Promise apromise[] = new Promise[acallable.length];
        int i = 0;
        while (i < acallable.length) 
        {
            if (acallable[i] instanceof DeferredCallable)
            {
                apromise[i] = when((DeferredCallable)acallable[i]);
            } else
            {
                apromise[i] = when(acallable[i]);
            }
            i++;
        }
        return when(apromise);
    }

    public transient Promise when(Future afuture[])
    {
        assertNotEmpty(afuture);
        Promise apromise[] = new Promise[afuture.length];
        for (int i = 0; i < afuture.length; i++)
        {
            apromise[i] = when(afuture[i]);
        }

        return when(apromise);
    }

    public transient Promise when(DeferredCallable adeferredcallable[])
    {
        assertNotEmpty(adeferredcallable);
        Promise apromise[] = new Promise[adeferredcallable.length];
        for (int i = 0; i < adeferredcallable.length; i++)
        {
            apromise[i] = when(adeferredcallable[i]);
        }

        return when(apromise);
    }

    public transient Promise when(DeferredFutureTask adeferredfuturetask[])
    {
        assertNotEmpty(adeferredfuturetask);
        Promise apromise[] = new Promise[adeferredfuturetask.length];
        for (int i = 0; i < adeferredfuturetask.length; i++)
        {
            apromise[i] = when(adeferredfuturetask[i]);
        }

        return when(apromise);
    }

    public transient Promise when(DeferredRunnable adeferredrunnable[])
    {
        assertNotEmpty(adeferredrunnable);
        Promise apromise[] = new Promise[adeferredrunnable.length];
        for (int i = 0; i < adeferredrunnable.length; i++)
        {
            apromise[i] = when(adeferredrunnable[i]);
        }

        return when(apromise);
    }

    public transient Promise when(Promise apromise[])
    {
        assertNotEmpty(apromise);
        return (new MasterDeferredObject(apromise)).promise();
    }
}