How to use

fail

method

in

io.baratine.stream.ResultStream

 @Override
 public void fail(Throwable exn)
 {
  _resultStream.fail(exn);
 }
}

@Override
public void fail(Throwable exn)
{
 _result.fail(exn);
}

@Override
public void fail(HeadersAmp headers, Throwable exn)
{
 synchronized (this) {
  _result.fail(exn);
 }
}

@Override
public void fail(Throwable exn)
{
 _result.fail(exn);
}

@Override
public void fail(Throwable e)
{
 _result.fail(e);
}

@Override
public void fail(Throwable exn)
{
 _result.fail(exn);
}

@Override
public void fail(Throwable exn)
{
 next().fail(exn);
}

@Override
public void fail(Throwable exn)
{
 getNext().fail(exn);
}

@Override
public void fail(Throwable e)
{
 next().fail(e);
}

default <U> Result<U> of(BiConsumer<U,ResultStream<T>> consumer)
{
 return Result.of(x->consumer.accept(x,this), exn->fail(exn));
}

 public void run()
 {
  try {
   _spliterator.forEachRemaining(_result);
  } catch (Throwable exn) {
   _result.fail(exn);;
  } finally {
   _result.ok();
  }
 }
}

@Override
public <T> void stream(HeadersAmp headers,
            ResultStream<T> result,
            StubAmp actor,
            Object []args)
{
 result.fail(new ServiceExceptionMethodNotFound(
              L.l("'{0}' is an undefined method for {1}",
                this, actor)));
}

@Override
public void accept(T value)
{
 _fun.apply(_value, value, (x,e)->{ 
  if (e != null) {
   next().fail(e);
  }
  else {
   _value = x;
  }
 });
}

private void fillStream(ResultStream<Cursor> result,
            Iterable<Cursor> iter)
{
 try {
  for (Cursor cursor : iter) {
   result.accept(cursor);
  }
  
  result.ok();
 } catch (Throwable e) {
  result.fail(e);
 }
}

public void findStream(ResultStream<Cursor> result, Object[] args)
{
 findAll(Result.of(iter->fillStream(result, iter), 
           e->result.fail(e)), 
     args);
}

private void readObjects(Iterable<Cursor> it, ResultStream<T> r)
{
 try {
  for (Cursor cursor : it) {
   T bean = _entityInfo.readObject(cursor, true);
   r.accept(bean);
  }
  r.ok();
 } catch (ReflectiveOperationException e) {
  //TODO log
  r.fail(e);
 }
}

private void readObjects(Iterable<Cursor> it, ResultStream<T> r)
{
 try {
  for (Cursor c : it) {
   T t = _entityDesc.readObject(c, true);
   r.accept(t);
  }
  r.ok();
 } catch (ReflectiveOperationException e) {
  //TODO log
  r.fail(e);
 }
}

 @Override
 public void accept(V value)
 {
  addPending();
  
  _consumer.accept(value, Result.of(x->{ subPending(); },
                    e->{
                     next().fail(e); 
                     subPending(); 
                    }));
 }
}

@Override
public void accept(T value)
{
 addPending();
 
 _fun.apply(_value, value, 
       Result.of(x->{ _value = x; subPending(); },
             e->{ next().fail(e); subPending(); }));
}

@Override
public void accept(T value)
{
 addPending();
 
 _map.apply(value, Result.of(x->{ 
  next().accept(x);
  
  subPending();
 },
 e->{ 
  next().fail(e);
  subPending();
 }));
}