io.vlingo.symbio.store.object.ObjectStore Java Examples

@BeforeEach
public void setUp() {
    final World world = TestWorld.start("calculation-test").world();

    final MapQueryExpression objectQuery =
            MapQueryExpression.using(Calculation.class, "find", MapQueryExpression.map("id", "id"));

    final ObjectStore objectStore =
            world.stage().actorFor(ObjectStore.class, InMemoryObjectStoreActor.class, new MockDispatcher());

    final StateObjectMapper stateObjectMapper =
            StateObjectMapper.with(CalculationState.class, new Object(), new Object());

    final ObjectTypeRegistry.Info<CalculationState> info =
            new ObjectTypeRegistry.Info(objectStore, CalculationState.class,
                    "ObjectStore", objectQuery, stateObjectMapper);

    new ObjectTypeRegistry(world).register(info);

    CalculationQueryProvider.using(world.stage(), objectStore);
}
 

private Bootstrap(final VlingoServer vlingoServer) {
    this.server = vlingoServer.getServer();
    this.world = vlingoServer.getVlingoScene().getWorld();

    final MapQueryExpression objectQuery =
            MapQueryExpression.using(Calculation.class, "find", MapQueryExpression.map("id", "id"));

    final ObjectStore objectStore =
            world.stage().actorFor(ObjectStore.class, InMemoryObjectStoreActor.class, new MockDispatcher());

    final StateObjectMapper stateObjectMapper =
            StateObjectMapper.with(Calculation.class, new Object(), new Object());

    final Info<CalculationState> info =
            new Info(objectStore, CalculationState.class,
                    "ObjectStore", objectQuery, stateObjectMapper);

    new ObjectTypeRegistry(world).register(info);

    CalculationQueryProvider.using(world.stage(), objectStore);

    Runtime.getRuntime().addShutdownHook(new Thread(() -> {
        stopAndCleanup();
    }));
}
 

@Before
@SuppressWarnings({ "rawtypes", "unchecked" })
public void setUp() {
  world = World.startWithDefaults("test-object-entity");
  objectStore = world.actorFor(ObjectStore.class, InMemoryObjectStoreActor.class, new MockDispatcher());

  registry = new ObjectTypeRegistry(world);

  // NOTE: The InMemoryObjectStoreActor implementation currently
  // does not use PersistentObjectMapper, and thus the no-op decl.
  final Info<Employee> employeeInfo =
          new Info(
          objectStore,
          EmployeeState.class,
          "HR-Database",
          MapQueryExpression.using(Employee.class, "find", MapQueryExpression.map("number", "number")),
          StateObjectMapper.with(Employee.class, new Object(), new Object()));

  registry.register(employeeInfo);
}
 

private Bootstrap(final VlingoServer vlingoServer) {
    this.server = vlingoServer.getServer();
    this.world = vlingoServer.getVlingoScene().getWorld();

    final MapQueryExpression objectQuery =
            MapQueryExpression.using(StockEntity.class, "find", MapQueryExpression.map("id", "id"));

    final ObjectStore objectStore =
            world.stage().actorFor(ObjectStore.class, InMemoryObjectStoreActor.class, new MockDispatcher());

    final StateObjectMapper stateObjectMapper =
            StateObjectMapper.with(StockEntity.class, new Object(), new Object());

    final Info<StockState> info =
            new Info(objectStore, StockState.class,
                    "ObjectStore", objectQuery, stateObjectMapper);

    new ObjectTypeRegistry(world).register(info);

    StockQueryProvider.using(world.stage(), objectStore);

    Runtime.getRuntime().addShutdownHook(new Thread(() -> {
        stopAndCleanup();
    }));
}
 

@BeforeEach
public void setUp() {
    final World world = TestWorld.start("stock-test").world();

    final MapQueryExpression objectQuery =
            MapQueryExpression.using(Stock.class, "find", MapQueryExpression.map("id", "id"));

    final ObjectStore objectStore =
            world.stage().actorFor(ObjectStore.class, InMemoryObjectStoreActor.class, new MockDispatcher());

    final StateObjectMapper stateObjectMapper =
            StateObjectMapper.with(Stock.class, new Object(), new Object());

    final Info<StockState> info =
            new Info(objectStore, StockState.class,
                    "ObjectStore", objectQuery, stateObjectMapper);

    new ObjectTypeRegistry(world).register(info);

    StockQueryProvider.using(world.stage(), objectStore);
}
 

@Before
@SuppressWarnings({ "unchecked", "rawtypes" })
public void setUp() throws Exception {
  grid = Grid.start("object-entity-test", Configuration.define(), ClusterProperties.oneNode(), "node1");
  grid.quorumAchieved();
  objectStore = grid.actorFor(ObjectStore.class, InMemoryObjectStoreActor.class, new MockDispatcher());
  registry = new ObjectTypeRegistry(grid.world());

  final Info<Organization> info =
          new Info(
          objectStore,
          io.vlingo.entity.object.State.class,
          "ObjectStore",
          MapQueryExpression.using(Organization.class, "find", MapQueryExpression.map("id", "id")),
          StateObjectMapper.with(Organization.class, new Object(), new Object()));

  registry.register(info);
}
 

@BeforeEach
public void setUp() {
    final World world = TestWorld.start("order-test").world();

    messagingClient = Mockito.mock(MessagingClient.class);
    applicationRegistry = Mockito.mock(ApplicationRegistry.class);
    Mockito.when(applicationRegistry.retrieveStage()).thenReturn(world.stage());
    Mockito.when(applicationRegistry.retrieveMessagingClient()).thenReturn(messagingClient);

    final MapQueryExpression objectQuery =
            MapQueryExpression.using(Order.class, "find", MapQueryExpression.map("id", "id"));

    final ObjectStore objectStore =
            world.stage().actorFor(ObjectStore.class, InMemoryObjectStoreActor.class, new MockDispatcher());

    final StateObjectMapper stateObjectMapper =
            StateObjectMapper.with(Order.class, new Object(), new Object());

    final ObjectTypeRegistry.Info<OrderState> info =
            new ObjectTypeRegistry.Info(objectStore, OrderState.class,
                    "ObjectStore", objectQuery, stateObjectMapper);

    new ObjectTypeRegistry(world).register(info);

    OrderQueryProvider.using(world.stage(), objectStore);
}
 

private Bootstrap(final VlingoServer vlingoServer) {
    this.server = vlingoServer.getServer();
    this.world = vlingoServer.getVlingoScene().getWorld();

    final MapQueryExpression objectQuery =
            MapQueryExpression.using(Order.class, "find", MapQueryExpression.map("id", "id"));

    final ObjectStore objectStore =
            world.stage().actorFor(ObjectStore.class, InMemoryObjectStoreActor.class, new MockDispatcher());

    final StateObjectMapper stateObjectMapper =
            StateObjectMapper.with(Order.class, new Object(), new Object());

    final Info<OrderState> info =
            new Info(objectStore, OrderState.class,
                    "ObjectStore", objectQuery, stateObjectMapper);

    new ObjectTypeRegistry(world).register(info);

    OrderQueryProvider.using(world.stage(), objectStore);

    Runtime.getRuntime().addShutdownHook(new Thread(() -> {
        stopAndCleanup();
    }));
}
 

@Before
@SuppressWarnings({ "unchecked", "rawtypes" })
public void setUp() {
  world = World.startWithDefaults("five-step-process-test");

  final MessageQueue queue = new AsyncMessageQueue(null);
  exchange = new LocalExchange(queue);
  final ProcessMessageTextAdapter adapter = new ProcessMessageTextAdapter();
  EntryAdapterProvider.instance(world).registerAdapter(ProcessMessage.class, adapter);

  dispatcher = new MockTextDispatcher();
  objectStore = world.actorFor(ObjectStore.class, InMemoryObjectStoreActor.class, dispatcher);

  objectTypeRegistry = new ObjectTypeRegistry(world);

  final Info<StepCountObjectState> stepCountStateInfo =
          new ObjectTypeRegistry.Info(
          objectStore,
          StepCountObjectState.class,
          StepCountObjectState.class.getSimpleName(),
          MapQueryExpression.using(StepCountObjectState.class, "find", MapQueryExpression.map("id", "id")),
          StateObjectMapper.with(StepCountObjectState.class, new Object(), new Object()));

  objectTypeRegistry.register(stepCountStateInfo);

  exchangeReceivers = new ExchangeReceivers();
  exchangeSender = new LocalExchangeSender(queue);

  registerExchangeCoveys();

  processTypeRegistry = new ProcessTypeRegistry(world);
  processTypeRegistry.register(new ObjectProcessInfo(FiveStepEmittingObjectProcess.class, FiveStepEmittingObjectProcess.class.getSimpleName(), exchange, objectTypeRegistry));
}
 

@Before
public void setUp() {
  persistInterest = new MockPersistResultInterest();
  queryResultInterest = new MockQueryResultInterest();
  world = World.startWithDefaults("test-object-store");
  final EntryAdapterProvider entryAdapterProvider = new EntryAdapterProvider(world);
  entryAdapterProvider.registerAdapter(Test1Source.class, new Test1SourceAdapter());

  this.dispatcher = new MockDispatcher<>(new MockConfirmDispatchedResultInterest());
  objectStore = world.actorFor(ObjectStore.class, InMemoryObjectStoreActor.class, this.dispatcher);
}
 

public OrderQueriesActor(final ObjectStore objectStore) {
    super(objectStore);
}
 

private CalculationQueryProvider(final Stage stage, final ObjectStore objectStore) {
    this.queries = stage.actorFor(CalculationQueries.class, CalculationQueriesActor.class, objectStore);
}
 

public static CalculationQueryProvider using(final Stage stage, final ObjectStore objectStore) {
    if(instance == null) {
        instance = new CalculationQueryProvider(stage, objectStore);
    }
    return instance;
}
 

public CalculationQueriesActor(final ObjectStore objectStore) {
    super(objectStore);
}
 

private OrderQueryProvider(final Stage stage, final ObjectStore objectStore) {
    this.queries = stage.actorFor(OrderQueries.class, OrderQueriesActor.class, objectStore);
}
 

public static OrderQueryProvider using(final Stage stage, final ObjectStore objectStore) {
    if(instance == null) {
        instance = new OrderQueryProvider(stage, objectStore);
    }
    return instance;
}
 

private StockQueryProvider(final Stage stage, final ObjectStore objectStore) {
    this.queries = stage.actorFor(StockQueries.class, StockQueriesActor.class, objectStore);
}
 

public static StockQueryProvider using(final Stage stage, final ObjectStore objectStore) {
    if(instance == null) {
        instance = new StockQueryProvider(stage, objectStore);
    }
    return instance;
}
 

public StockQueriesActor(final ObjectStore objectStore) {
    super(objectStore);
}
 

/**
 * Construct my state.
 * @param objectStore the ObjectStore the query
 */
protected StateObjectQueryActor(final ObjectStore objectStore) {
  this.objectStore = objectStore;
  this.queryResultInterest = selfAs(QueryResultInterest.class);
}
 

/**
 * Construct my default state.
 * @param store the ObjectStore instance
 * @param storeType the {@code Class<T>} Object type that uses the ObjectStore
 * @param storeName the String name of the ObjectStore
 * @param queryObjectExpression the QueryExpression used to retrieve a single instance
 * @param mapper the PersistentObjectMapper between Object type and persistent type
 */
public Info(final ObjectStore store, final Class<T> storeType, final String storeName, final QueryExpression queryObjectExpression, final StateObjectMapper mapper) {
  this.store = store;
  this.storeType = storeType;
  this.storeName = storeName;
  this.queryObjectExpression = queryObjectExpression;
  this.mapper = mapper;
}