// Decompiled by DJ v3.11.11.95 Copyright 2009 Atanas Neshkov  Date: 26/10/2010 13:51:27
// Home Page: http://members.fortunecity.com/neshkov/dj.html  http://www.neshkov.com/dj.html - Check often for new version!
// Decompiler options: packimports(3) 

package jcircus.classesdescompiladas;


// Referenced classes of package org.jcsp.lang:
//            Guard, AltingBarrierBase, AltingBarrierError, Alternative, 
//            CSTimer, MultiwaySynchronisation

public class AltingBarrier extends Guard
    implements MultiwaySynchronisation
{

    AltingBarrier(AltingBarrierBase altingbarrierbase, AltingBarrier altingbarrier)
    {
        next = null;
        alt = null;
        myThread = null;
        enrolled = true;
        singleAlt = null;
        pollAlt = null;
        pollTime = null;
        base = altingbarrierbase;
        next = altingbarrier;
    }

    public static AltingBarrier[] create(int i)
    {
        if(i <= 0)
            throw new IllegalArgumentException("\n*** An AltingBarrier must have at least one process enrolled, not " + i);
        else
            return (new AltingBarrierBase()).expand(i);
    }

    public static AltingBarrier create()
    {
        return (new AltingBarrierBase()).expand();
    }

    public AltingBarrier[] expand(int i)
    {
        if(i <= 0)
            throw new IllegalArgumentException("\n*** Expanding an AltingBarrier must be by at least one, not " + i);
        AltingBarrierBase altingbarrierbase = base;
        JVM INSTR monitorenter ;
        if(myThread == null)
            myThread = Thread.currentThread();
        else
        if(myThread != Thread.currentThread())
            throw new AltingBarrierError("\n*** AltingBarrier expand attempted by non-owner.");
        if(!enrolled)
            throw new AltingBarrierError("\n*** AltingBarrier expand attempted whilst resigned.");
        return base.expand(i);
        Exception exception;
        exception;
        throw exception;
    }

    public AltingBarrier expand()
    {
        AltingBarrierBase altingbarrierbase = base;
        JVM INSTR monitorenter ;
        if(myThread == null)
            myThread = Thread.currentThread();
        else
        if(myThread != Thread.currentThread())
            throw new AltingBarrierError("\n*** AltingBarrier expand attempted by non-owner.");
        if(!enrolled)
            throw new AltingBarrierError("\n*** AltingBarrier expand attempted whilst resigned.");
        return base.expand();
        Exception exception;
        exception;
        throw exception;
    }

    public void contract(AltingBarrier aaltingbarrier[])
    {
        if(aaltingbarrier == null)
            throw new IllegalArgumentException("\n*** AltingBarrier contract given a null array.");
        if(aaltingbarrier.length == 0)
            throw new IllegalArgumentException("\n*** AltingBarrier contract given an empty array.");
        synchronized(base)
        {
            if(myThread != Thread.currentThread())
                throw new AltingBarrierError("\n*** AltingBarrier contract attempted by non-owner.");
            if(!enrolled)
                throw new AltingBarrierError("\n*** AltingBarrier contract attempted whilst resigned.");
            base.contract(aaltingbarrier);
        }
    }

    public void contract()
    {
        synchronized(base)
        {
            if(myThread != Thread.currentThread())
                throw new AltingBarrierError("\n*** AltingBarrier contract attempted by non-owner.");
            if(!enrolled)
                throw new AltingBarrierError("\n*** AltingBarrier contract attempted whilst resigned.");
            base.contract(this);
        }
    }

    boolean enable(Alternative alternative)
    {
        AltingBarrierBase altingbarrierbase = base;
        JVM INSTR monitorenter ;
        if(myThread == null)
            myThread = Thread.currentThread();
        else
        if(myThread != Thread.currentThread())
            throw new AltingBarrierError("\n*** AltingBarrier front-end enable by more than one Thread.");
        if(!enrolled)
            throw new AltingBarrierError("\n*** AltingBarrier front-end enable whilst resigned.");
        if(alt != null)
            return false;
        if(!base.enable()) goto _L2; else goto _L1
_L1:
        alternative.setBarrierTrigger();
        true;
        altingbarrierbase;
        JVM INSTR monitorexit ;
        return;
_L2:
        alt = alternative;
        false;
        altingbarrierbase;
        JVM INSTR monitorexit ;
        return;
        Exception exception;
        exception;
        throw exception;
    }

    boolean disable()
    {
        AltingBarrierBase altingbarrierbase = base;
        JVM INSTR monitorenter ;
        if(alt == null)
            return false;
        if(!base.disable()) goto _L2; else goto _L1
_L1:
        alt.setBarrierTrigger();
        alt = null;
        true;
        altingbarrierbase;
        JVM INSTR monitorexit ;
        return;
_L2:
        alt = null;
        false;
        altingbarrierbase;
        JVM INSTR monitorexit ;
        return;
        Exception exception;
        exception;
        throw exception;
    }

    void schedule()
    {
        if(alt != null)
            alt.schedule();
    }

    public void resign()
    {
        synchronized(base)
        {
            if(!enrolled)
                throw new AltingBarrierError("\n*** AltingBarrier.resign() whilst not enrolled.");
            enrolled = false;
            base.resign();
        }
    }

    public void enroll()
    {
        synchronized(base)
        {
            if(enrolled)
                throw new AltingBarrierError("\n*** AltingBarrier.enroll() whilst not resigned.");
            enrolled = true;
            base.enroll();
        }
    }

    public void mark()
    {
        synchronized(base)
        {
            if(!enrolled)
                throw new AltingBarrierError("\n*** Attempt to AltingBarrier.mark() a resigned front-end.");
            myThread = Thread.currentThread();
        }
    }

    public void reset()
    {
        synchronized(base)
        {
            if(!enrolled)
            {
                enrolled = true;
                base.enroll();
            }
            myThread = null;
        }
    }

    public void sync()
    {
        if(singleAlt == null)
            singleAlt = new Alternative(new Guard[] {
                this
            });
        singleAlt.priSelect();
    }

    public boolean poll(long l)
    {
        if(pollAlt == null)
        {
            pollTime = new CSTimer();
            pollAlt = new Alternative(new Guard[] {
                this, pollTime
            });
        }
        pollTime.setAlarm(pollTime.read() + l);
        return pollAlt.priSelect() == 0;
    }

    AltingBarrierBase base;
    AltingBarrier next;
    private Alternative alt;
    private Thread myThread;
    boolean enrolled;
    private Alternative singleAlt;
    private Alternative pollAlt;
    private CSTimer pollTime;
}