io.vlingo.common.SerializableConsumer Java Examples

@Override
public io.vlingo.common.Completes<io.vlingo.symbio.store.journal.StreamReader<T>> streamReader(final java.lang.String arg0) {
  if (!actor.isStopped()) {
    final SerializableConsumer<Journal> consumer = (actor) -> actor.streamReader(arg0);
    final io.vlingo.common.Completes<io.vlingo.symbio.store.journal.StreamReader<T>> completes = new BasicCompletes<>(
            actor.scheduler());
    if (mailbox.isPreallocated()) {
      mailbox.send(actor, Journal.class, consumer, Returns.value(completes), streamReaderRepresentation6);
    } else {
      mailbox.send(new LocalMessage<>(actor, Journal.class, consumer, Returns.value(completes), streamReaderRepresentation6));
    }
    return completes;
  } else {
    actor.deadLetters().failedDelivery(new DeadLetter(actor, streamReaderRepresentation6));
  }
  return null;
}
 

@Override
public void unsubscribe(io.vlingo.http.resource.sse.SseSubscriber arg0) {
  if (!actor.isStopped()) {
    final SerializableConsumer<SsePublisher> consumer = (actor) -> actor.unsubscribe(arg0);
    if (mailbox.isPreallocated()) { mailbox.send(actor, SsePublisher.class, consumer, null, unsubscribeRepresentation2); }
    else { mailbox.send(new LocalMessage<SsePublisher>(actor, SsePublisher.class, consumer, unsubscribeRepresentation2)); }
  } else {
    actor.deadLetters().failedDelivery(new DeadLetter(actor, unsubscribeRepresentation2));
  }
}
 

@Override
public <T>io.vlingo.common.Completes<java.util.Optional<io.vlingo.lattice.grid.spaces.KeyItem<T>>> take(io.vlingo.lattice.grid.spaces.Key arg0, io.vlingo.lattice.grid.spaces.Period arg1) {
  if (!actor.isStopped()) {
    ActorProxyBase<Space> self = this;
    final SerializableConsumer<Space> consumer = (actor) -> actor.take(ActorProxyBase.thunk(self, (Actor)actor, arg0), ActorProxyBase.thunk(self, (Actor)actor, arg1));
    final io.vlingo.common.Completes<java.util.Optional<io.vlingo.lattice.grid.spaces.KeyItem<T>>> returnValue = Completes.using(actor.scheduler());
    if (mailbox.isPreallocated()) { mailbox.send(actor, Space.class, consumer, Returns.value(returnValue), takeRepresentation3); }
    else { mailbox.send(new LocalMessage<Space>(actor, Space.class, consumer, Returns.value(returnValue), takeRepresentation3)); }
    return returnValue;
  } else {
    actor.deadLetters().failedDelivery(new DeadLetter(actor, takeRepresentation3));
  }
  return null;
}
 

@Override
public Completes<Boolean> startUp() {
  if (!actor.isStopped()) {
    final SerializableConsumer<Server> consumer = (actor) -> actor.startUp();
    final Completes<Boolean> completes = new BasicCompletes<>(actor.scheduler());
    if (mailbox.isPreallocated()) { mailbox.send(actor, Server.class, consumer, Returns.value(completes), startUpRepresentation2); }
    else { mailbox.send(new LocalMessage<Server>(actor, Server.class, consumer, Returns.value(completes), startUpRepresentation2)); }
    return completes;
  } else {
    actor.deadLetters().failedDelivery(new DeadLetter(actor, startUpRepresentation2));
  }
  return null;
}
 

@Override
public void conclude() {
  if (!actor.isStopped()) {
    final SerializableConsumer<Stoppable> consumer = (actor) -> actor.conclude();
    if (mailbox.isPreallocated()) { mailbox.send(actor, Stoppable.class, consumer, null, representationConclude0); }
    else { mailbox.send(new LocalMessage<Stoppable>(actor, Stoppable.class, consumer, representationConclude0)); }
  } else {
    actor.deadLetters().failedDelivery(new DeadLetter(actor, representationConclude0));
  }
}
 

public void confirmDispatchedResultedIn(io.vlingo.symbio.store.Result arg0, java.lang.String arg1) {
  if (!actor.isStopped()) {
    final SerializableConsumer<ConfirmDispatchedResultInterest> consumer = (actor) -> actor.confirmDispatchedResultedIn(arg0, arg1);
    if (mailbox.isPreallocated()) { mailbox.send(actor, ConfirmDispatchedResultInterest.class, consumer, null, confirmDispatchedResultedInRepresentation1); }
    else { mailbox.send(new LocalMessage<ConfirmDispatchedResultInterest>(actor, ConfirmDispatchedResultInterest.class, consumer, confirmDispatchedResultedInRepresentation1)); }
  } else {
    actor.deadLetters().failedDelivery(new DeadLetter(actor, confirmDispatchedResultedInRepresentation1));
  }
}
 

private void send(final SerializableConsumer<Dispatcher> consumer, final String representation) {
  if (!actor.isStopped()) {
    if (mailbox.isPreallocated()) {
      mailbox.send(actor, Dispatcher.class, consumer, null, representation);
    } else {
      mailbox.send(new LocalMessage<>(actor, Dispatcher.class, consumer, representation));
    }
  } else {
    actor.deadLetters().failedDelivery(new DeadLetter(actor, representation));
  }
}
 

@Override
public Completes<Response> requestWith(io.vlingo.http.Request arg0, io.vlingo.common.Completes<Response> arg1) {
  if (!actor.isStopped()) {
    final SerializableConsumer<ClientConsumer> consumer = (actor) -> actor.requestWith(arg0, arg1);
    final Completes<Response> completes = new BasicCompletes<>(actor.scheduler());
    if (mailbox.isPreallocated()) { mailbox.send(actor, ClientConsumer.class, consumer, Returns.value(completes), requestWithRepresentation1); }
    else { mailbox.send(new LocalMessage<ClientConsumer>(actor, ClientConsumer.class, consumer, Returns.value(completes), requestWithRepresentation1)); }
    return completes;
  } else {
    actor.deadLetters().failedDelivery(new DeadLetter(actor, requestWithRepresentation1));
  }
  return null;
}
 

private void send(final SerializableConsumer<DispatcherControl> consumer, final String representation) {
  if (!actor.isStopped()) {
    if (mailbox.isPreallocated()) {
      mailbox.send(actor, DispatcherControl.class, consumer, null, representation);
    } else {
      mailbox.send(new LocalMessage<>(actor, DispatcherControl.class, consumer, representation));
    }
  } else {
    actor.deadLetters().failedDelivery(new DeadLetter(actor, representation));
  }
}
 

@Override
public void dispatchFor(io.vlingo.http.Context arg0) {
  if (!actor.isStopped()) {
    final SerializableConsumer<Dispatcher> consumer = (actor) -> actor.dispatchFor(arg0);
    if (mailbox.isPreallocated()) { mailbox.send(actor, Dispatcher.class, consumer, null, dispatchForRepresentation1); }
    else { mailbox.send(new LocalMessage<Dispatcher>(actor, Dispatcher.class, consumer, dispatchForRepresentation1)); }
  } else {
    actor.deadLetters().failedDelivery(new DeadLetter(actor, dispatchForRepresentation1));
  }
}
 

public void projectWith(io.vlingo.lattice.model.projection.Projectable arg0, io.vlingo.lattice.model.projection.ProjectionControl arg1) {
  if (!actor.isStopped()) {
    final SerializableConsumer<Projection> consumer = (actor) -> actor.projectWith(arg0, arg1);
    if (mailbox.isPreallocated()) { mailbox.send(actor, Projection.class, consumer, null, projectWithRepresentation1); }
    else { mailbox.send(new LocalMessage<Projection>(actor, Projection.class, consumer, projectWithRepresentation1)); }
  } else {
    actor.deadLetters().failedDelivery(new DeadLetter(actor, projectWithRepresentation1));
  }
}
 

public Deliver(final Class<T> protocol,
               final Address address,
               final Definition.SerializationProxy definition,
               final SerializableConsumer<T> consumer,
               final String representation) {
  this(protocol, address, definition, consumer, null, representation);
}
 

@Override
public <T>io.vlingo.common.Completes<io.vlingo.lattice.grid.spaces.KeyItem<T>> put(io.vlingo.lattice.grid.spaces.Key arg0, io.vlingo.lattice.grid.spaces.Item<T> arg1) {
  if (!actor.isStopped()) {
    ActorProxyBase<Space> self = this;
    final SerializableConsumer<Space> consumer = (actor) -> actor.put(ActorProxyBase.thunk(self, (Actor)actor, arg0), ActorProxyBase.thunk(self, (Actor)actor, arg1));
    final io.vlingo.common.Completes<io.vlingo.lattice.grid.spaces.KeyItem<T>> returnValue = Completes.using(actor.scheduler());
    if (mailbox.isPreallocated()) { mailbox.send(actor, Space.class, consumer, Returns.value(returnValue), putRepresentation2); }
    else { mailbox.send(new LocalMessage<Space>(actor, Space.class, consumer, Returns.value(returnValue), putRepresentation2)); }
    return returnValue;
  } else {
    actor.deadLetters().failedDelivery(new DeadLetter(actor, putRepresentation2));
  }
  return null;
}
 

public void projectTo(io.vlingo.lattice.model.projection.Projection arg0, java.lang.String[] arg1) {
  if (!actor.isStopped()) {
    final SerializableConsumer<ProjectionDispatcher> consumer = (actor) -> actor.projectTo(arg0, arg1);
    if (mailbox.isPreallocated()) { mailbox.send(actor, ProjectionDispatcher.class, consumer, null, projectToRepresentation1); }
    else { mailbox.send(new LocalMessage<ProjectionDispatcher>(actor, ProjectionDispatcher.class, consumer, projectToRepresentation1)); }
  } else {
    actor.deadLetters().failedDelivery(new DeadLetter(actor, projectToRepresentation1));
  }
}
 

@Override
public void conclude() {
  if (!actor.isStopped()) {
    final SerializableConsumer<Stoppable> consumer = (actor) -> actor.conclude();
    if (mailbox.isPreallocated()) { mailbox.send(actor, Stoppable.class, consumer, null, representationConclude0); }
    else { mailbox.send(new LocalMessage<Stoppable>(actor, Stoppable.class, consumer, representationConclude0)); }
  } else {
    actor.deadLetters().failedDelivery(new DeadLetter(actor, representationConclude0));
  }
}
 

@Override
public void attachPrivateToken(String arg0) {
  if (!actor.isStopped()) {
    final SerializableConsumer<User> consumer = (actor) -> actor.attachPrivateToken(arg0);
    mailbox.send(new LocalMessage<User>(actor, User.class, consumer, null, attachPrivateToken1));
  } else {
    actor.deadLetters().failedDelivery(new DeadLetter(actor, attachPrivateToken1));
  }
}
 

@Override
public <T extends StateObject, E> void persist(final StateSources<T,E> arg0, final Metadata arg1,
        final long arg2, final PersistResultInterest arg3, final Object arg4) {
  final SerializableConsumer<ObjectStore> consumer = (actor) -> actor
          .persist(arg0, arg1, arg2, arg3, arg4);
  send(ObjectStore__Proxy.persistRepresentation15, consumer);
}
 

@Override
public Completes<EntryReader<? extends Entry<?>>> entryReader(final String arg0) {
  if (!actor.isStopped()) {
    final SerializableConsumer<ObjectStore> consumer = (actor) -> actor.entryReader(arg0);
    final Completes<EntryReader<? extends Entry<?>>> completes = new BasicCompletes<>(actor.scheduler());
    if (mailbox.isPreallocated()) { mailbox.send(actor, ObjectStore.class, consumer, Returns.value(completes), entryReaderRepresentation2); }
    else { mailbox.send(new LocalMessage<ObjectStore>(actor, ObjectStore.class, consumer, Returns.value(completes), entryReaderRepresentation2)); }
    return completes;
  } else {
    actor.deadLetters().failedDelivery(new DeadLetter(actor, entryReaderRepresentation2));
  }
  return null;
}
 

@Override
public void stop() {
  if (!actor.isStopped()) {
    final SerializableConsumer<SsePublisher> consumer = (actor) -> actor.stop();
    if (mailbox.isPreallocated()) { mailbox.send(actor, SsePublisher.class, consumer, null, stopRepresentation3); }
    else { mailbox.send(new LocalMessage<SsePublisher>(actor, SsePublisher.class, consumer, stopRepresentation3)); }
  } else {
    actor.deadLetters().failedDelivery(new DeadLetter(actor, stopRepresentation3));
  }
}
 

public Completes<UserData> userDataOf(java.lang.String arg0) {
  if (!actor.isStopped()) {
    final SerializableConsumer<Queries> consumer = (actor) -> actor.userDataOf(arg0);
    final Completes<io.vlingo.frontservice.data.UserData> completes = new BasicCompletes<>(actor.scheduler());
    mailbox.send(new LocalMessage<Queries>(actor, Queries.class, consumer, Returns.value(completes), userDataOfRepresentation2));
    return completes;
  } else {
    actor.deadLetters().failedDelivery(new DeadLetter(actor, userDataOfRepresentation2));
  }
  return null;
}
 

@Override
public <P,C extends Command,A> void route(io.vlingo.lattice.router.RoutableCommand<P,C,A> arg0) {
  if (!actor.isStopped()) {
    ActorProxyBase<CommandRouter> self = this;
    final SerializableConsumer<CommandRouter> consumer = (a) -> a.route(ActorProxyBase.thunk(self, (Actor)a, arg0));
    if (mailbox.isPreallocated()) { mailbox.send(actor, CommandRouter.class, consumer, Returns.value(arg0.answer()), routeRepresentation1); }
    else { mailbox.send(new LocalMessage<CommandRouter>(actor, CommandRouter.class, consumer, Returns.value(arg0.answer()), routeRepresentation1)); }
  } else {
    actor.deadLetters().failedDelivery(new DeadLetter(actor, routeRepresentation1));
  }
}
 

@Override
public Completes<Stream> streamSomeUsing(final QueryExpression query) {
  if (!actor.isStopped()) {
    final SerializableConsumer<StateStore> consumer = (actor) -> actor.streamSomeUsing(query);
    final Completes<Stream> completes = new BasicCompletes<>(actor.scheduler());
    if (mailbox.isPreallocated()) { mailbox.send(actor, StateStore.class, consumer, Returns.value(completes), streamSomeUsingRepresentation5); }
    else { mailbox.send(new LocalMessage<StateStore>(actor, StateStore.class, consumer, Returns.value(completes), streamSomeUsingRepresentation5)); }
    return completes;
  } else {
    actor.deadLetters().failedDelivery(new DeadLetter(actor, streamSomeUsingRepresentation5));
  }
  return null;
}
 

@Override
public Completes<Stream> streamAllOf(final Class<?> stateType) {
  if (!actor.isStopped()) {
    final SerializableConsumer<StateStore> consumer = (actor) -> actor.streamAllOf(stateType);
    final Completes<Stream> completes = new BasicCompletes<>(actor.scheduler());
    if (mailbox.isPreallocated()) { mailbox.send(actor, StateStore.class, consumer, Returns.value(completes), streamAllOfRepresentation4); }
    else { mailbox.send(new LocalMessage<StateStore>(actor, StateStore.class, consumer, Returns.value(completes), streamAllOfRepresentation4)); }
    return completes;
  } else {
    actor.deadLetters().failedDelivery(new DeadLetter(actor, streamAllOfRepresentation4));
  }
  return null;
}
 

public Completes<UserState> withName(Name arg0) {
  if (!actor.isStopped()) {
    final SerializableConsumer<User> consumer = (actor) -> actor.withName(arg0);
    final Completes<UserState> completes = new BasicCompletes<>(actor.scheduler());
    mailbox.send(new LocalMessage<User>(actor, User.class, consumer, Returns.value(completes), withNameRepresentation3));
    return completes;
  } else {
    actor.deadLetters().failedDelivery(new DeadLetter(actor, withNameRepresentation3));
  }
  return null;
}
 

@Override
public void readAll(final Collection<TypedStateBundle> arg0, final ReadResultInterest arg1, final Object arg2) {
  if (!actor.isStopped()) {
    final SerializableConsumer<StateStore> consumer = (actor) -> actor.readAll(arg0, arg1, arg2);
    if (mailbox.isPreallocated()) { mailbox.send(actor, StateStore.class, consumer, null, readRepresentation2a); }
    else { mailbox.send(new LocalMessage<StateStore>(actor, StateStore.class, consumer, readRepresentation2a)); }
  } else {
    actor.deadLetters().failedDelivery(new DeadLetter(actor, readRepresentation2a));
  }
}
 

@Override
public void read(java.lang.String arg0, java.lang.Class<?> arg1, io.vlingo.symbio.store.state.StateStore.ReadResultInterest arg2, java.lang.Object arg3) {
  if (!actor.isStopped()) {
    final SerializableConsumer<StateStore> consumer = (actor) -> actor.read(arg0, arg1, arg2, arg3);
    if (mailbox.isPreallocated()) { mailbox.send(actor, StateStore.class, consumer, null, readRepresentation2); }
    else { mailbox.send(new LocalMessage<StateStore>(actor, StateStore.class, consumer, readRepresentation2)); }
  } else {
    actor.deadLetters().failedDelivery(new DeadLetter(actor, readRepresentation2));
  }
}
 

public <S>void readResultedIn(io.vlingo.common.Outcome<io.vlingo.symbio.store.StorageException, io.vlingo.symbio.store.Result> arg0, java.lang.String arg1, S arg2, int arg3, io.vlingo.symbio.Metadata arg4, java.lang.Object arg5) {
  if (!actor.isStopped()) {
    final SerializableConsumer<ReadResultInterest> consumer = (actor) -> actor.readResultedIn(arg0, arg1, arg2, arg3, arg4, arg5);
    if (mailbox.isPreallocated()) { mailbox.send(actor, ReadResultInterest.class, consumer, null, readResultedInRepresentation1); }
    else { mailbox.send(new LocalMessage<ReadResultInterest>(actor, ReadResultInterest.class, consumer, readResultedInRepresentation1)); }
  } else {
    actor.deadLetters().failedDelivery(new DeadLetter(actor, readResultedInRepresentation1));
  }
}
 

@Override
public Completes<Stream> streamAll() {
  if (!actor.isStopped()) {
    final SerializableConsumer<StateStoreEntryReader> consumer = (actor) -> actor.streamAll();
    final io.vlingo.common.Completes<Stream> completes = new BasicCompletes<>(actor.scheduler());
    if (mailbox.isPreallocated()) { mailbox.send(actor, StateStoreEntryReader.class, consumer, Returns.value(completes), streamAllRepresentation10); }
    else { mailbox.send(new LocalMessage<StateStoreEntryReader>(actor, StateStoreEntryReader.class, consumer, Returns.value(completes), streamAllRepresentation10)); }
    return completes;
  } else {
    actor.deadLetters().failedDelivery(new DeadLetter(actor, streamAllRepresentation10));
  }
  return null;
}
 

@Override
public io.vlingo.common.Completes<java.lang.String> seekTo(java.lang.String arg0) {
  if (!actor.isStopped()) {
    final SerializableConsumer<StateStoreEntryReader> consumer = (actor) -> actor.seekTo(arg0);
    final io.vlingo.common.Completes<java.lang.String> completes = new BasicCompletes<>(actor.scheduler());
    if (mailbox.isPreallocated()) { mailbox.send(actor, StateStoreEntryReader.class, consumer, Returns.value(completes), seekToRepresentation9); }
    else { mailbox.send(new LocalMessage<StateStoreEntryReader>(actor, StateStoreEntryReader.class, consumer, Returns.value(completes), seekToRepresentation9)); }
    return completes;
  } else {
    actor.deadLetters().failedDelivery(new DeadLetter(actor, seekToRepresentation9));
  }
  return null;
}
 

@Override
public io.vlingo.common.Completes<T> readNext() {
  if (!actor.isStopped()) {
    final SerializableConsumer<StateStoreEntryReader> consumer = (actor) -> actor.readNext();
    final io.vlingo.common.Completes<T> completes = new BasicCompletes<>(actor.scheduler());
    if (mailbox.isPreallocated()) { mailbox.send(actor, StateStoreEntryReader.class, consumer, Returns.value(completes), readNextRepresentation8); }
    else { mailbox.send(new LocalMessage<StateStoreEntryReader>(actor, StateStoreEntryReader.class, consumer, Returns.value(completes), readNextRepresentation8)); }
    return completes;
  } else {
    actor.deadLetters().failedDelivery(new DeadLetter(actor, readNextRepresentation8));
  }
  return null;
}