rt.async.AsyncUtils Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of rts-pipeline Show documentation
Framework to build reactive services for reactive application front-ends
The newest version!
package rt.async;

import java.util.Timer;
import java.util.TimerTask;
import org.eclipse.xtend.lib.annotations.Accessors;
import org.eclipse.xtext.xbase.lib.Exceptions;
import org.eclipse.xtext.xbase.lib.Functions.Function0;
import org.eclipse.xtext.xbase.lib.Procedures.Procedure0;
import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
import org.eclipse.xtext.xbase.lib.Pure;
import rt.async.promise.Promise;
import rt.async.pubsub.IPublisher;

@SuppressWarnings("all")
public abstract class AsyncUtils {
  public static class DefaultAsyncUtils extends AsyncUtils {
    public DefaultAsyncUtils() {
      this(false, 3000L);
    }
    
    public DefaultAsyncUtils(final boolean isWorker) {
      this(isWorker, 3000L);
    }
    
    public DefaultAsyncUtils(final boolean isWorker, final long timeout) {
      super(isWorker, timeout);
    }
    
    @Override
    public void setTimer(final long delay, final Procedure0 callback) {
      Timer _timer = new Timer();
      final TimerTask _function = new TimerTask() {
        @Override
        public void run() {
          callback.apply();
        }
      };
      _timer.schedule(_function, delay);
    }
    
    @Override
    public void setPeriodic(final long delay, final Procedure0 callback) {
      throw new UnsupportedOperationException("setPeriodic");
    }
    
    @Override
    public void setAsyncWhile(final Function0 evaluate, final Function0 onWhileTrue, final Procedure0 onReturn, final Procedure1 onError) {
      try {
        while (((evaluate.apply()).booleanValue() && (onWhileTrue.apply()).booleanValue())) {
        }
        onReturn.apply();
      } catch (final Throwable _t) {
        if (_t instanceof Exception) {
          final Exception ex = (Exception)_t;
          onError.apply(ex);
        } else {
          throw Exceptions.sneakyThrow(_t);
        }
      }
    }
    
    @Override
    public void setWaitUntil(final Function0 evaluate, final Procedure0 onReturn) {
      while ((!(evaluate.apply()).booleanValue())) {
      }
      onReturn.apply();
    }
    
    @Override
    public  Promise setTask(final Function0 execute) {
      throw new UnsupportedOperationException("setTask");
    }
  }
  
  private final static ThreadLocal local = new ThreadLocal();
  
  public static AsyncUtils get() {
    return AsyncUtils.local.get();
  }
  
  public static void set(final AsyncUtils instance) {
    AsyncUtils.local.set(instance);
  }
  
  public static void setDefault() {
    AsyncUtils.DefaultAsyncUtils _defaultAsyncUtils = new AsyncUtils.DefaultAsyncUtils();
    AsyncUtils.local.set(_defaultAsyncUtils);
  }
  
  public static void setDefault(final long timeout) {
    AsyncUtils.DefaultAsyncUtils _defaultAsyncUtils = new AsyncUtils.DefaultAsyncUtils(false, timeout);
    AsyncUtils.local.set(_defaultAsyncUtils);
  }
  
  public static IPublisher getPublisher() {
    AsyncUtils _get = AsyncUtils.local.get();
    return _get.publisher;
  }
  
  public static void setPublisher(final IPublisher publisher) {
    AsyncUtils _get = AsyncUtils.local.get();
    _get.publisher = publisher;
  }
  
  public static boolean isWorker() {
    AsyncUtils _get = AsyncUtils.local.get();
    return _get.isWorker;
  }
  
  public static void schedule(final Procedure0 callback) {
    AsyncUtils _get = AsyncUtils.local.get();
    _get.setTimer(0, callback);
  }
  
  public static void timeout(final Procedure0 callback) {
    AsyncUtils _get = AsyncUtils.local.get();
    _get.setTimeout(callback);
  }
  
  public static void timer(final long delay, final Procedure0 callback) {
    AsyncUtils _get = AsyncUtils.local.get();
    _get.setTimer(delay, callback);
  }
  
  public static void periodic(final long delay, final Procedure0 callback) {
    AsyncUtils _get = AsyncUtils.local.get();
    _get.setPeriodic(delay, callback);
  }
  
  public static void waitUntil(final Function0 evaluate, final Procedure0 onReturn) {
    AsyncUtils _get = AsyncUtils.local.get();
    _get.setWaitUntil(evaluate, onReturn);
  }
  
  public static void asyncWhile(final Function0 evaluate, final Function0 onWhileTrue, final Procedure0 onReturn, final Procedure1 onError) {
    AsyncUtils _get = AsyncUtils.local.get();
    _get.setAsyncWhile(evaluate, onWhileTrue, onReturn, onError);
  }
  
  public static  Promise task(final Function0 execute) {
    AsyncUtils _get = AsyncUtils.local.get();
    return _get.setTask(execute);
  }
  
  @Accessors
  private IPublisher publisher = null;
  
  @Accessors
  private final boolean isWorker;
  
  @Accessors
  private final long timeout;
  
  public AsyncUtils(final boolean isWorker, final long timeout) {
    this.isWorker = isWorker;
    this.timeout = timeout;
  }
  
  public void setTimeout(final Procedure0 callback) {
    this.setTimer(this.timeout, callback);
  }
  
  public abstract void setTimer(final long delay, final Procedure0 callback);
  
  public abstract void setPeriodic(final long delay, final Procedure0 callback);
  
  public abstract void setAsyncWhile(final Function0 evaluate, final Function0 onWhileTrue, final Procedure0 onReturn, final Procedure1 onError);
  
  public abstract void setWaitUntil(final Function0 evaluate, final Procedure0 onReturn);
  
  public abstract  Promise setTask(final Function0 execute);
  
  @Pure
  public long getTimeout() {
    return this.timeout;
  }
}