io.vlingo.actors.Address Java Examples

static Completes<CalculationState> calculate(final Stage stage,
                                             final Operation operation,
                                             final Integer anOperand,
                                             final Integer anotherOperand) {

    final Completes<Set<CalculationState>> calculations =
            CalculationQueryProvider.instance().queries().allCalculations();

    return calculations.andThenTo(existingCalculations -> {
        final Address address =
                stage.addressFactory().uniqueWith(generateName());

        final Definition definition =
                Definition.has(CalculationEntity.class, Definition.parameters(CalculationId.from(address.idString())));

        final Calculation calculation = stage.actorFor(Calculation.class, definition, address);

        return calculation.calculate(operation, anOperand, anotherOperand, existingCalculations);
    });
}
 

@Override
public void relocate(
        final Id receiver,
        final Id sender,
        final Definition.SerializationProxy definitionProxy,
        final Address address,
        final Object snapshot, List<? extends io.vlingo.actors.Message> pending) {

  final List<Deliver<?>> messages =
          pending
            .stream()
            .map(Deliver.from(correlation))
            .collect(Collectors.toList());

  send(receiver, new Relocate(address, definitionProxy, snapshot, messages));
}
 

static Completes<OrderState> register(final ApplicationRegistry registry,
                                      final ProductId productId,
                                      final Integer quantity,
                                      final Site site) {

    final Stage stage = registry.retrieveStage();

    final MessagingClient messagingClient = registry.retrieveMessagingClient();

    final Address address = stage.addressFactory().uniqueWith(generateName());

    final OrderId orderId = OrderId.from(address.idString());

    final Order order =
            stage.actorFor(Order.class,
                    Definition.has(OrderEntity.class, Definition.parameters(orderId)), address);

    final DomainEventNotifier notifier =
            stage.actorFor(DomainEventNotifier.class,
                    Definition.has(DomainEventNotifierActor.class, Definition.parameters(messagingClient)));

    return order.register(productId, quantity, site).andThen(newOrder -> {
        notifier.notify(new OrderWasRegistered(productId, quantity, site));
        return newOrder;
    });
}
 

private Completes<ObjectResponse<String>> create(final OrderCreateRequest request) {
    final Address orderAddress = addressFactory.uniquePrefixedWith("order-");
    Map<ProductId, Integer> quantityByProductId = new HashMap<>();
    request.quantityByIdOfProduct.forEach((key, value) -> quantityByProductId.put(new ProductId(key), value));


    Order orderActor = stage.actorFor(
            Order.class,
            Definition.has(OrderActor.class,
                    Definition.parameters(orderAddress.idString())),
            orderAddress);

    orderActor.initOrderForUserProducts(request.userId, quantityByProductId);
    return Completes.withSuccess(
            ObjectResponse.of(Created,
                    headers(of(Location, urlLocation(orderAddress.idString()))),
                    ""));
}
 

static Tuple2<ProductId, Product> defineWith(
        final Stage stage,
        final Tenant tenant,
        final ProductOwner productOwner,
        final String name,
        final String description,
        final boolean hasDiscussion) {

    assert (tenant != null && tenant.id != null);
    assert (productOwner != null && productOwner.id != null);
    assert (name != null);
    assert (description != null);

    Address address = stage.addressFactory().unique();
    final ProductId productId = ProductId.fromExisting(address.idString());
    final Definition definition = Definition.has(ProductEntity.class, Definition.parameters(tenant, productId), productId.id);
    final Product product = stage.actorFor(Product.class, definition);
    product.define(productOwner, name, description, hasDiscussion);
    return Tuple2.from(productId, product);
}
 

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);
}
 

/**
 * Construct my default state.
 * @param actor the Actor inside being tested
 * @param protocol the T protocol being tested
 * @param address the Address of the actor
 */
public TestActor(final Actor actor, final T protocol, final Address address) {
  this.actor = actor;
  this.protocolActor = protocol;
  this.address = address;
  this.context = new TestContext();

  this.actor.viewTestStateInitialization(context);
}
 

public LogEvent(final Class<?> source, final String sourceThread, final Instant eventTimestamp, final String message, final Object[] args,
                final Throwable throwable, final Address sourceActorAddress) {
  this.source = source;
  this.message = message;
  this.args = args;
  this.throwable = throwable;
  this.sourceThread = sourceThread;
  this.eventTimestamp = eventTimestamp;
  this.sourceActorAddress = sourceActorAddress;
}
 

static Completes<OrganizationState> with(
        final Stage stage,
        final Class<? extends Actor> entityType,
        final Id organizationId,
        final String name,
        final String description) {
  final String actorName = nameFrom(organizationId);
  final Address address = stage.addressFactory().from(organizationId.value, actorName);
  final Definition definition = Definition.has(entityType, Definition.parameters(organizationId), actorName);
  final Organization organization = stage.actorFor(Organization.class, definition, address);
  return organization.defineWith(name, description);
}
 

static Completes<StockState> unload(final Stage stage, final Location location, final ItemId itemId, final Integer quantity) {
    return StockQueryProvider.instance()
            .queries().queryByLocation(location)
            .andThenTo(state -> {
                final Address address = stage.addressFactory().from(state.stockId().value);
                return stage.actorOf(Stock.class, address);
            })
            .andThenTo(stock -> stock.unload(itemId, quantity));
}
 

static Completes<StockState> increaseAvailabilityFor(final Stage stage, final Location location, final ItemId itemId, final Integer quantity) {
    return StockQueryProvider.instance()
            .queries().queryByLocation(location)
            .andThenTo(state -> {
                final Address address = stage.addressFactory().from(state.stockId().value);
                return stage.actorOf(Stock.class, address);
            })
            .andThenTo(stock -> stock.increaseAvailabilityFor(itemId, quantity));
}
 

static Completes<StockState> openIn(final Stage stage, final Location location) {
    final Address address =
            stage.addressFactory().uniqueWith(generateName());

    final StockId stockId = StockId.from(address.idString());

    final Stock stock =
            stage.actorFor(Stock.class,
                    Definition.has(StockEntity.class, Definition.parameters(stockId)), address);

    return stock.openIn(location);
}
 

public Completes<ObjectResponse<String>> create(final UserId userId) {
    final Address cartAddress = addressFactory.uniquePrefixedWith("cart-");
    final Cart cartActor = stage.actorFor(
            Cart.class,
            Definition.has(CartActor.class, Definition.parameters(cartAddress.idString())),
            cartAddress);

    cartActor.createEmptyCartFor(userId);

    final Headers<ResponseHeader> headers = headers(of(Location, urlLocation(cartAddress.idString())));
    return Completes.withSuccess(ObjectResponse.of(Created, headers, ""));
}
 

public Completes<Response> register(final UserData userData) {
  final Address userAddress = addressFactory.uniquePrefixedWith("u-");

  final User.UserState userState =
    User.from(
      userAddress.idString(),
      Name.from(userData.nameData.given, userData.nameData.family),
      Contact.from(userData.contactData.emailAddress, userData.contactData.telephoneNumber),
      Security.from(userData.publicSecurityToken));

  stage.actorFor(User.class, Definition.has(UserEntity.class, Definition.parameters(userState)), userAddress);

  return Completes.withSuccess(Response.of(Created, headers(of(Location, userLocation(userState.id))), serialized(UserData.from(userState))));
}
 

public Completes<Response> register(final UserData userData) {
  final Address userAddress = ServerBootstrap.instance.world.addressFactory().uniquePrefixedWith("u-"); // stage().world().addressFactory().uniquePrefixedWith("u-");
  final User.State userState =
          User.from(
                  userAddress.idString(),
                  Name.from(userData.nameData.given, userData.nameData.family),
                  Contact.from(userData.contactData.emailAddress, userData.contactData.telephoneNumber));

  stage.actorFor(User.class, Definition.has(UserActor.class, Definition.parameters(userState)), userAddress);

  repository.save(userState);

  return Completes.withSuccess(Response.of(Created, headers(of(Location, userLocation(userState.id))), serialized(UserData.from(userState))));
}
 

void relocate(
final Id receiver,
final Id sender,
final Definition.SerializationProxy definitionProxy,
final Address address,
final Object snapshot,
final List<? extends io.vlingo.actors.Message> pending);
 

<T> void deliver(
final Id recipient,
final Id sender,
final Returns<?> returns,
final Class<T> protocol,
final Address address,
final Definition.SerializationProxy definitionProxy,
final SerializableConsumer<T> consumer,
final String representation);
 

@Override
public <T> void start(
        final Id recipient,
        final Id sender,
        final Class<T> protocol,
        final Address address,
        final Definition.SerializationProxy definitionProxy) {

  send(recipient, new Start<>(protocol, address, definitionProxy));
}
 

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

@Override
public Address address() {
  return null;
}
 

@Override
public Address address() {
  return null;
}
 

@Override
public CompletesEventually provideCompletesFor(final Address address, final Returns<?> clientReturns) {
  ++provideCompletesForCount;
  return completesEventually;
}
 

public List<Message> allMessagesFor(final Address address) {
  final List<Message> all = actorMessages.get(address.id());
  
  return all == null ? new ArrayList<>() : all;
}
 

public Start(Class<T> protocol, Address address, Definition.SerializationProxy definition) {
  this.protocol = protocol;
  this.address = address;
  this.definition = definition;
}
 

public Builder withSourceActorAddress(final Address sourceActorAddress) {
  this.sourceActorAddress = sourceActorAddress;
  return this;
}
 

public Optional<Address> getSourceActorAddress() {
  return Optional.ofNullable(sourceActorAddress);
}
 

public Relocate(Address address, Definition.SerializationProxy definition, Object snapshot, List<Deliver<?>> pending) {
  this.address = address;
  this.definition = definition;
  this.snapshot = snapshot;
  this.pending = pending;
}
 

private Address address(final String id) {
  return grid.addressFactory().from(id);
}
 

private Address address(final String id) {
  return grid.addressFactory().from(id);
}
 

private Address address(final String id) {
  return grid.addressFactory().from(id);
}