rt.pipeline.pipe.channel.ChannelBuffer Maven / Gradle / Ivy

Go to download
package rt.pipeline.pipe.channel;

import com.google.common.base.Objects;
import java.nio.channels.FileChannel;
import org.eclipse.xtend2.lib.StringConcatenation;
import org.eclipse.xtext.xbase.lib.Exceptions;
import org.eclipse.xtext.xbase.lib.Procedures.Procedure0;
import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
import org.slf4j.Logger;
import rt.pipeline.pipe.channel.ChannelPump;

@SuppressWarnings("all")
public abstract class ChannelBuffer {
  public static class Signal {
    public final static String SIGNAL_BEGIN = "bgn";
    
    public final static String SIGNAL_BEGIN_CONFIRM = "bgn-cnf";
    
    public final static String SIGNAL_END = "end";
    
    public final static String SIGNAL_END_CONFIRM = "end-cnf";
    
    public final static String SIGNAL_ERROR = "err";
    
    public final String flag;
    
    public final String name;
    
    public final String message;
    
    private Signal(final String flag, final String name) {
      this(flag, name, null);
    }
    
    private Signal(final String flag, final String name, final String message) {
      this.flag = flag;
      this.name = name;
      this.message = message;
    }
    
    public static ChannelBuffer.Signal begin(final String name) {
      return new ChannelBuffer.Signal(ChannelBuffer.Signal.SIGNAL_BEGIN, name);
    }
    
    public static ChannelBuffer.Signal end(final String name) {
      return new ChannelBuffer.Signal(ChannelBuffer.Signal.SIGNAL_END, name);
    }
    
    public static ChannelBuffer.Signal error(final String name, final String message) {
      return new ChannelBuffer.Signal(ChannelBuffer.Signal.SIGNAL_ERROR, name, message);
    }
    
    public static ChannelBuffer.Signal beginConfirm(final String name) {
      return new ChannelBuffer.Signal(ChannelBuffer.Signal.SIGNAL_BEGIN_CONFIRM, name);
    }
    
    public static ChannelBuffer.Signal endConfirm(final String name) {
      return new ChannelBuffer.Signal(ChannelBuffer.Signal.SIGNAL_END_CONFIRM, name);
    }
    
    public static ChannelBuffer.Signal process(final String msg) {
      final String[] firstSplits = msg.split(":", 2);
      int _length = firstSplits.length;
      boolean _lessThan = (_length < 2);
      if (_lessThan) {
        return null;
      }
      final String signal = firstSplits[0];
      final String value = firstSplits[1];
      final String[] secondSplits = value.split(":", 2);
      final String name = secondSplits[0];
      String _xifexpression = null;
      int _length_1 = secondSplits.length;
      boolean _greaterThan = (_length_1 > 1);
      if (_greaterThan) {
        _xifexpression = secondSplits[1];
      } else {
        _xifexpression = null;
      }
      final String message = _xifexpression;
      return new ChannelBuffer.Signal(signal, name, message);
    }
    
    @Override
    public String toString() {
      StringConcatenation _builder = new StringConcatenation();
      _builder.append(this.flag, "");
      _builder.append(":");
      _builder.append(this.name, "");
      {
        boolean _notEquals = (!Objects.equal(this.message, null));
        if (_notEquals) {
          _builder.append(":");
          _builder.append(this.message, "");
        }
      }
      return _builder.toString();
    }
  }
  
  public abstract Logger getLogger();
  
  protected final ChannelPump inPump;
  
  protected final ChannelPump outPump;
  
  protected boolean isLocked = false;
  
  protected boolean needConfirmation = false;
  
  protected String signalName = "";
  
  protected FileChannel fileChannel = null;
  
  private Procedure0 onEnd = null;
  
  private Procedure1 onError = null;
  
  public void onEnd(final Procedure0 onEnd) {
    this.onEnd = onEnd;
  }
  
  public void onError(final Procedure1 onError) {
    this.onError = onError;
  }
  
  public ChannelBuffer(final ChannelPump inPump, final ChannelPump outPump) {
    this.outPump = outPump;
    this.inPump = inPump;
  }
  
  public void error(final String error) {
    this.endError(error, true);
  }
  
  public void close() {
    if (this.isLocked) {
      this.endError("Irregular close!");
    }
  }
  
  protected void endOk() {
    this.endOk(null);
  }
  
  protected void endOk(final ChannelBuffer.Signal signal) {
    Logger _logger = this.getLogger();
    _logger.debug("endOk");
    if (this.onEnd!=null) {
      this.onEnd.apply();
    }
    boolean _notEquals = (!Objects.equal(signal, null));
    if (_notEquals) {
      this.outPump.pushSignal(signal);
    }
    this.reset();
  }
  
  protected void endError(final String error) {
    this.endError(error, false);
  }
  
  private void endError(final String error, final boolean sendSignal) {
    Logger _logger = this.getLogger();
    _logger.error("endError: {}", error);
    if (this.onError!=null) {
      this.onError.apply(error);
    }
    if (sendSignal) {
      ChannelBuffer.Signal _error = ChannelBuffer.Signal.error(this.signalName, error);
      this.outPump.pushSignal(_error);
    }
    this.reset();
  }
  
  private void reset() {
    try {
      this.isLocked = false;
      this.needConfirmation = false;
      if (this.fileChannel!=null) {
        this.fileChannel.close();
      }
      this.fileChannel = null;
      this.signalName = "";
    } catch (Throwable _e) {
      throw Exceptions.sneakyThrow(_e);
    }
  }
}