public StateReducer <T> Wrap(StateReducer <T> wrappedReducer)
{
return((T present, object action) => {
var newPresent = wrappedReducer(present, action);
if (action is ServerAction sa)
{
var serverActions = MutateServerActions(present, sa);
newPresent.serverOutbox = new ServerOutbox()
{
serverActions = serverActions
};
}
else if (action is RemoveServerAction fa)
{
var serverActions = present.serverOutbox.serverActions.Remove(fa.finishedServerAction);
newPresent.serverOutbox = new ServerOutbox()
{
serverActions = serverActions
};
}
else
{
newPresent.serverOutbox = present.serverOutbox;
}
return newPresent;
});
}
public static T Mutate <T>(this T self, bool applyReducer, object action, StateReducer <T> reducer, ref bool changed)
{
if (!applyReducer)
{
return(self);
}
var newVal = reducer(self, action);
changed = changed || !Object.Equals(self, newVal);
AssertValid(self, newVal);
return(newVal);
}
public StateReducer <T> wrap(StateReducer <T> wrappedReducer)
{
return((T present, object action) => {
if (action is UndoAction <T> )
{
return RestoreFrom(past, present, future);
}
if (action is RedoAction <T> )
{
return RestoreFrom(future, present, past);
}
var newPresent = wrappedReducer(present, action);
past.Push(present);
future.Clear();
return newPresent;
});
}
private ForkedStore(StateReducer <T> reducer, T initialState, List <object> actions, params Middleware <T>[] middlewares)
: base(reducer, initialState, AddCollectMiddleWare(actions, middlewares))
{
this.recordedActions = actions;
}
public ForkedStore(IDataStore <T> storeToFork, StateReducer <T> reducer, params Middleware <T>[] middlewares)
: this(reducer, storeToFork.GetState(), new List <object>(), middlewares)
{
this.forkedStore = storeToFork;
}
public static T Mutate <T>(this T self, object action, StateReducer <T> reducer, ref bool changed)
{
return(self.Mutate <T>(true, action, reducer, ref changed));
}
public static ImmutableDictionary <T, V> MutateEntries <T, V>(this ImmutableDictionary <T, V> list, object action, StateReducer <V> reducer)
{
if (list != null)
{
foreach (var elem in list)
{
var newValue = reducer(elem.Value, action);
if (!Object.Equals(newValue, elem.Value))
{
list = list.SetItem(elem.Key, newValue);
}
}
}
return(list);
}
public static ImmutableList <T> MutateEntries <T>(this ImmutableList <T> list, object action, StateReducer <T> reducer)
{
if (list != null)
{
foreach (var elem in list)
{
var newElem = reducer(elem, action);
if (!Object.Equals(newElem, elem))
{
list = list.Replace(elem, newElem);
}
}
}
return(list);
}
public DataStore(StateReducer <T> reducer, T initialState = default(T), params Middleware <T>[] middlewares)
{
this.state = initialState;
this.reducer = reducer;
dispatcher = ApplyMiddlewares(middlewares);
}
public static IList <T> MutateEntries <T>(this IList <T> list, object action, StateReducer <T> reducer, ref bool changed)
{
if (list != null)
{
for (int i = 0; i < list.Count; i++)
{
var elem = list[i];
var newElem = reducer(elem, action);
if (StateCompare.WasModified(elem, newElem))
{
list[i] = newElem;
changed = true;
}
}
}
return(list);
}
public static ImmutableDictionary <T, V> MutateEntry <T, V>(this ImmutableDictionary <T, V> dict, T key, object action, StateReducer <V> reducer)
{
var elem = dict[key];
var newValue = reducer(elem, action);
if (StateCompare.WasModified(elem, newValue))
{
dict = dict.SetItem(key, newValue);
}
return(dict);
}
public static ImmutableDictionary <T, V> MutateEntries <T, V>(this ImmutableDictionary <T, V> dict, object action, StateReducer <V> reducer)
{
if (dict != null)
{
foreach (var elem in dict)
{
var newValue = reducer(elem.Value, action);
if (StateCompare.WasModified(elem.Value, newValue))
{
dict = dict.SetItem(elem.Key, newValue);
}
}
}
return(dict);
}
