EclipseStore

implementation("org.eclipse.store:storage-embedded:<current-version>")                    (1)
implementation("org.eclipse.serializer:persistence-binary-jdk8:<current-version>")
implementation("org.eclipse.serializer:persistence-binary-jdk17:<current-version>")

EmbeddedStorageManager storageManager = EmbeddedStorage.start();                          (1)
storageManager.setRoot("Hello World");                                                    (2)
storageManager.storeRoot();                                                               (3)

public interface Provider<T> {
    static <E extends HasOid, Long> Optional<E> findByOid(@NotNull Provider<E> provider,
            long oid) {
        return provider.findBy(E::oid, oid);
    }

    static <E extends HasId, String> Optional<E> findById(@NotNull Provider<E> provider,
            @NotNull String id) {
        return provider.findBy(E::id, id);
    }

    /**
     * Return a list containing all known instances of the entity type.
     *
     * @return list of all instances
     */
    List<T> items();

    /**
     * Update the data associated with the entity. If the entity is new, the update is handled
     * as a create operation. The update is transitive and all referenced entities are also
     * updated. The entity given as parameter becomes the instance managed through the provider.
     *
     * @param entity entity to update
     */
    void update(@NotNull T entity);

    /**
     * Delete the data associated with the entity. The object identifier is invalidated.
     *
     * @param entity entity to delete
     */
    void delete(@NotNull T entity);

    /**
     * Delete all the entities managed by the provider.
     */
    void deleteAll();


    /**
     * Replace an existing value with a new one. A null value is ignored.
     *
     * @param oldValue remove the old value if not null
     * @param newValue add the new value if not null
     */
    default void replace(T oldValue, T newValue) {
        if (Objects.nonNull(oldValue)) {
            delete(oldValue);
        }
        if (Objects.nonNull(newValue)) {
            update(newValue);
        }
    }

    /**
     * Update the data associated with all entities.
     *
     * @param items entities to update
     */
    default void updateAll(@NotNull Iterable<? extends T> items) {
        items.forEach(this::update);
    }


    /**
     * Return the first entity which property matches the value.
     *
     * @param getter getter to retrieve the property
     * @param value  value to compare with
     * @param <U>    type of the property
     * @return optional of the first matching entity otherwise empty
     */
    default <U> Optional<T> findBy(@NotNull Function<T, U> getter, U value) {
        return items().stream().filter(o -> value.equals(getter.apply(o))).findAny();
    }
}

class DomainEntities {
    static class Data {                                                                   (1)
        private final List<Lead> leads;
        private final List<NaturalEntity> naturalEntities;

        Data() {
            leads = new ArrayList<>();
            naturalEntities = new ArrayList<>();
        }
    }

    private final Data data;
    private final Provider<Lead> leads;
    private final Provider<NaturalEntity> naturalEntities;

    public DomainEntities(@NotNull Path path) {
        this.data = new Data();
        storageManager = EmbeddedStorage.start(data, path);                               (2)

        leads = ProviderPersistence.of(storageManager, data.leads);                       (3)
        naturalEntities = ProviderPersistence.of(storageManager, data.naturalEntities);
    }

    public Provider<Lead> leads() {                                                       (4)
        return this.leads;
    }

    public Provider<NaturalEntity> naturalEntities() {
        return this.naturalEntities;
    }
}