Abstract extension of the defined trait to minimize trait bloat.
Generates a Store backed by a MutableCache.
A store that is made from looking up values in the first store, then using that as the key in the second When used with ConvertedStore you can do some powerful sequential processing of stores
A simple JMapStore whose underlying store is a Java ConcurrentHashMap useful if you are going to be modifying a store from many threads, something you in general cannot do unless the docs specifically say that a store is safe for that.
N - total replicas One - 1 successful operation is sufficient to consider the operation as complete Quorum - N/2 + 1 successful operations are sufficient to consider the operation as complete All - N successful operations are required
Convert the keys/values of a store.
Use an injection on V2,V1 to convert a store of values V2.
Enrichment on the ReadableStore trait.
Enrichment on the Store[K, V] trait.
A type to represent how Seq of futures are collected into a future of Seq[T]
Simple wrapper on IndexedSeq[V] to make it accessible as a ReadableStore
A Store instance which is backed by a Java Map (by default JHashMap) Obviously, there is no optimization of the multiGet/multiPut methods on this store and these are just implemented using the default implementation from Store.
MapStore is a ReadableStore backed by a scala immutable Map.
This is only thrown when a shard is expected but somehow absent.
This is only thrown when a value is expected but somehow absent.
Thrown when a read operation fails due to unsatisfied consistency level
Main trait to represent asynchronous readable stores Here you see the tri-state logic:
Replicates reads to a seq of stores and returns the first successful value (empty or not)
Replicates writes to all stores, and takes the first successful read.
Use the ReadableStore abstraction when each read from the backend store involves a time-taking task.
Delegate put to the underlying store and allow retriable semantics for get.
Returns a ReadableStore that attempts reads out of the supplied Seq[ReadableStore] in order and returns the first non-exceptional value that satisfies the supplied predicate.
combines a mapping of ReadableStores into one ReadableStore that internally routes Note: if K1 is absent from the routes, you will always get Future.
combines a mapping of Stores into one Store that internally routes Note: if a K1 is absent from the routes, any put will give a
Main trait for mutable stores.
Replicates reads to a seq of stores and returns the value based on picked read consistency.
Replicates writes to a seq of stores, and returns after picked write consistency is satisfied.
ReadableStore enrichment which presents a ReadableStore[K, V] over top of a packed ReadableStore[OuterK, Map[InnerK, V]].
Store enrichment which presents a Store[K, V] over top of a packed Store[OuterK, Map[InnerK, V]].
Trait for building mutable store with TTL.
Thrown when a write operation fails due to unsatisfied consistency level
Helpful transformations on maps and collections.
Concrete empty store implementation.
Some factory methods and instances of FutureCollector that are used in storehaus
Some combinators on Futures or Seqs of Futures that are used internally These should arguably exist in util-core.
Methods used in the various unpivot stores.
Holds various factory and transformation functions for ReadableStore instances
Factory methods to create ShardedReadableStore instances
Factory methods to create ShardedStore instances
Factory methods and some combinators on Stores
Factory method to create TunableReplicatedStore instances