Store5 Documentation

To begin using Store5, follow these recommended steps:

1. Quickstart: Follow the Quickstart guide to build your first Store instance.
2. Learn Core Concepts: Read the Store Foundations documentation to understand the underlying architecture and how Store works.
3. Advanced Operations: For complex data management, refer to the guide on Handling CRUD to learn how to support create, read, update, and delete operations.

Add the shaded Guava subset to your project. This artifact is Kotlin Multiplatform compatible.

implementation("org.mobilenativefoundation.store:cache:${STORE_VERSION}")

The AndroidConventionPlugin is a Gradle plugin that automates the setup of Android library projects. When applied, it automatically configures the following plugins:

• com.android.library (Android Library)
• com.vanniktech.maven.publish (Maven Publishing)
• org.jetbrains.dokka (Documentation generation)
• maven-publish (Standard Maven publishing)
• org.jetbrains.kotlinx.binary-compatibility-validator (API compatibility checking)
• org.mobilenativefoundation.store.formatting (Project formatting)

It also configures compileSdk, minSdk, targetSdk, lint rules, testOptions, and compileOptions (Java/Kotlin JVM compatibility) using values from your project's versionCatalog.

To create a cache, use CacheBuilder<K, V>() where K is your key type and V is your value type. You can configure properties such as maximumSize and expireAfterWrite before calling .build().

Example with a Key data class and a Post data class:

data class Key(
    val id: String
)

data class Post(
    val title: String
)

val cache = CacheBuilder<Key, Post>()
    .maximumSize(100)
    .expireAfterWrite(1.day)
    .build()

Use MemoryPolicy.builder() to configure the in-memory caching behavior for Store5. You can configure expiration policies, maximum size, or maximum weight.

Important Constraints:

• Expiration: You can set either setExpireAfterWrite or setExpireAfterAccess, but not both.
• Sizing: You can set either setMaxSize (count-based) or setWeigherAndMaxWeight (weight-based), but not both.
• Defaults: DEFAULT_DURATION_POLICY is Duration.INFINITE and DEFAULT_SIZE_POLICY is -1 (unlimited).

Use the following methods to retrieve data from the cache:

• getIfPresent(key: Key): Output?: Returns the cached value if it exists for the given key (either a StoreKey.Single or StoreKey.Collection), otherwise returns null.
• getOrPut(key: Key, valueProducer: () -> Output): Output: Returns the cached value if present. If not, executes the valueProducer function, stores the result in the cache, and returns it.
• getAllPresent(keys: List<*>): Map<Key, Output>: Returns a map of all keys in the list that are currently present in the cache.
• getAllPresent(): Map<Key, Output>: Returns a map of all entries currently in the cache.

StoreMultiCache is a caching system that manages both single items and collections through decomposition. It allows you to store and retrieve data using StoreKey.Single or StoreKey.Collection keys. When you put a single item, it can automatically update the corresponding collection if a KeyProvider is provided.

To instantiate it, you must provide a KeyProvider and optionally provide custom Cache instances for singles and collections (which default to using CacheBuilder).

Call newDownstream() to obtain a Flow<T> that collects values dispatched by the Multicaster's single upstream source.

Parameters

• piggybackOnly: If true, this downstream will not trigger a new upstream to start running. This is only valid if piggybackingDownstream was set to true during Multicaster initialization. If false (default), the downstream will start the upstream if no other upstream is currently running.

Call the suspend function close() to shut down the Multicaster.

When closed:

1. All current collectors on the downstream flows will complete.
2. Any new collectors will receive zero values and immediately close (even if a positive bufferSize was configured).
3. This operation is idempotent.

To control how long entries stay in the in-memory cache, use one of the following methods in the MemoryPolicyBuilder:

1. Write-based expiration: Use setExpireAfterWrite(expireAfterWrite: Duration). The entry expires after a fixed duration since it was written.
2. Access-based expiration: Use setExpireAfterAccess(expireAfterAccess: Duration). The entry expires after a fixed duration since it was last accessed.

Note: You cannot use both policies simultaneously.