public IEnumerable <T> Stores <T, K, V>(StoreQueryParameters <T, K, V> storeQueryParameters)
where T : class
{
string storeName = storeQueryParameters.StoreName;
IQueryableStoreType <T, K, V> queryableStoreType = storeQueryParameters.QueryableStoreType;
IStateStore stateStore;
if (!globalStateStores.TryGetValue(storeName, out stateStore) || !queryableStoreType.Accepts(stateStore))
{
return(Enumerable.Empty <T>());
}
if (!stateStore.IsOpen)
{
throw new InvalidStateStoreException($"the state store, {storeName}, is not open.");
}
if (stateStore is ITimestampedKeyValueStore <K, V> && queryableStoreType is KeyValueStoreType <K, V> )
{
return(new[] { new ReadOnlyKeyValueStoreFacade <K, V>(stateStore as ITimestampedKeyValueStore <K, V>) as T });
}
else if (stateStore is ITimestampedWindowStore <K, V> && queryableStoreType is WindowStoreType <K, V> )
{
return(new[] { new ReadOnlyWindowStoreFacade <K, V>(stateStore as ITimestampedWindowStore <K, V>) as T });
}
else
{
return new[] { stateStore as T }
};
}
}
public IEnumerable <T> Stores <T, K, V>(StoreQueryParameters <T, K, V> storeQueryParameters)
where T : class
{
string storeName = storeQueryParameters.StoreName;
IQueryableStoreType <T, K, V> queryableStoreType = storeQueryParameters.QueryableStoreType;
IStateStore stateStore;
if (!globalStateStores.TryGetValue(storeName, out stateStore) || !queryableStoreType.Accepts(stateStore))
{
return(Enumerable.Empty <T>());
}
if (!stateStore.IsOpen)
{
throw new InvalidStateStoreException($"the state store, {storeName}, is not open.");
}
if (stateStore is TimestampedKeyValueStore <K, V> && queryableStoreType is KeyValueStoreType <K, V> )
{
return(new[] { new ReadOnlyKeyValueStoreFacade <K, V>(stateStore as TimestampedKeyValueStore <K, V>) as T });
}
// TODO: handle TimestampedWindowStore
//} else if (store instanceof TimestampedWindowStore && queryableStoreType instanceof QueryableStoreTypes.WindowStoreType) {
// return (List<T>) Collections.singletonList(new ReadOnlyWindowStoreFacade((TimestampedWindowStore<Object, Object>) store));
//}
return(new[] { stateStore as T });
}
public CompositeReadOnlyKeyValueStore(
IStateStoreProvider <IReadOnlyKeyValueStore <K, V>, K, V> storeProvider,
IQueryableStoreType <IReadOnlyKeyValueStore <K, V>, K, V> storeType, string storeName)
{
this.storeProvider = storeProvider;
this.storeType = storeType;
this.storeName = storeName;
}
/// <summary>
/// Provides access to <see cref="Processors.IStateStore"/>s accepted by <see cref="IQueryableStoreType{T, K, V}.Accepts(IStateStore)"/>
/// </summary>
/// <param name="storeName">Name of the store</param>
/// <param name="queryableStoreType">The <see cref="IQueryableStoreType{T, K, V}"/></param>
/// <returns>a List of all the stores with the storeName and accepted by<see cref="IQueryableStoreType{T, K, V}.Accepts(IStateStore)"/></returns>
public IEnumerable <T> Stores(string storeName, IQueryableStoreType <T, K, V> queryableStoreType)
{
var allStores = storeProviders
.SelectMany(store => store.Stores(storeQueryParameters));
if (!allStores.Any())
{
throw new InvalidStateStoreException($"The state store, {storeName}, may have migrated to another instance.");
}
return(allStores);
}
public IEnumerable <IReadOnlyKeyValueStore <K, V> > Stores(string storeName,
IQueryableStoreType <IReadOnlyKeyValueStore <K, V>, K, V> queryableStoreType)
{
return
(stores
.Where(s => s.Name.Equals(storeName))
.Select <ITimestampedKeyValueStore <K, V>, IReadOnlyKeyValueStore <K, V> >(s =>
{
if (s is IReadOnlyKeyValueStore <K, V> )
{
return s as IReadOnlyKeyValueStore <K, V>;
}
else if (s is ITimestampedKeyValueStore <K, V> )
{
return new ReadOnlyKeyValueStoreFacade <K, V>(s);
}
else
{
return null;
}
}));
}
public IEnumerable <T> Stores(string storeName, IQueryableStoreType <T, K, V> queryableStoreType)
{
return(this.globalStateStoreProvider.Stores(StoreQueryParameters.FromNameAndType(storeName, queryableStoreType)));
}
/// <summary>
/// Creates <see cref="StoreQueryParameters{T, K, V}"/> with specified storeName and queryableStoreType
/// </summary>
/// <typeparam name="T">The type of the Store to be fetched</typeparam>
/// <typeparam name="K">The type of key</typeparam>
/// <typeparam name="V">The type of value</typeparam>
/// <param name="storeName">The name of the state store that should be queried.</param>
/// <param name="queryableStoreType">The <see cref="IQueryableStoreType{T, K, V}"/> for which key is queried by the user.</param>
/// <returns><see cref="StoreQueryParameters{T, K, V}"/> with provided <code>name</code> and <code>queryableStoreType</code></returns>
public static StoreQueryParameters <T, K, V> FromNameAndType <T, K, V>(string storeName, IQueryableStoreType <T, K, V> queryableStoreType) where T : class
{
return(new StoreQueryParameters <T, K, V>(storeName, queryableStoreType, null, false));
}
public CompositeReadOnlyWindowStore(IStateStoreProvider <ReadOnlyWindowStore <K, V>, K, V> storeProvider, WindowStoreType <K, V> storeType, string storeName)
{
this.storeProvider = storeProvider;
this.storeType = storeType;
this.storeName = storeName;
}
public IEnumerable <ReadOnlyWindowStore <K, V> > Stores(string storeName, IQueryableStoreType <ReadOnlyWindowStore <K, V>, K, V> queryableStoreType)
{
return
(stores
.Where(s => s.Name.Equals(storeName))
.Select <TimestampedWindowStore <K, V>, ReadOnlyWindowStore <K, V> >(s =>
{
if (s is ReadOnlyWindowStore <K, V> )
{
return s as ReadOnlyWindowStore <K, V>;
}
else if (s is TimestampedWindowStore <K, V> )
{
return new ReadOnlyWindowStoreFacade <K, V>(s);
}
else
{
return null;
}
}));
}
