// 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("
  *** 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("
  *** 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("
  *** AltingBarrier expand attempted by non-owner.");
          if(!enrolled)
              throw new AltingBarrierError("
  *** 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("
  *** AltingBarrier expand attempted by non-owner.");
          if(!enrolled)
              throw new AltingBarrierError("
  *** AltingBarrier expand attempted whilst resigned.");
          return base.expand();
          Exception exception;
          exception;
          throw exception;
      }
  
      public void contract(AltingBarrier aaltingbarrier[])
      {
          if(aaltingbarrier == null)
              throw new IllegalArgumentException("
  *** AltingBarrier contract given a null array.");
          if(aaltingbarrier.length == 0)
              throw new IllegalArgumentException("
  *** AltingBarrier contract given an empty array.");
          synchronized(base)
          {
              if(myThread != Thread.currentThread())
                  throw new AltingBarrierError("
  *** AltingBarrier contract attempted by non-owner.");
              if(!enrolled)
                  throw new AltingBarrierError("
  *** AltingBarrier contract attempted whilst resigned.");
              base.contract(aaltingbarrier);
          }
      }
  
      public void contract()
      {
          synchronized(base)
          {
              if(myThread != Thread.currentThread())
                  throw new AltingBarrierError("
  *** AltingBarrier contract attempted by non-owner.");
              if(!enrolled)
                  throw new AltingBarrierError("
  *** 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("
  *** AltingBarrier front-end enable by more than one Thread.");
          if(!enrolled)
              throw new AltingBarrierError("
  *** 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("
  *** AltingBarrier.resign() whilst not enrolled.");
              enrolled = false;
              base.resign();
          }
      }
  
      public void enroll()
      {
          synchronized(base)
          {
              if(enrolled)
                  throw new AltingBarrierError("
  *** AltingBarrier.enroll() whilst not resigned.");
              enrolled = true;
              base.enroll();
          }
      }
  
      public void mark()
      {
          synchronized(base)
          {
              if(!enrolled)
                  throw new AltingBarrierError("
  *** 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;
  }