From 65767cfc36cf8658b45d68b3c17d4bd612198165 Mon Sep 17 00:00:00 2001 From: Raimo Niskanen Date: Fri, 19 Feb 2016 09:22:52 +0100 Subject: Add {keep_state,...} and {keep_state_and_data,...} --- lib/stdlib/doc/src/gen_statem.xml | 61 ++++++++++++++++++++++++++---------- lib/stdlib/src/gen_statem.erl | 46 +++++++++++++++++++-------- lib/stdlib/test/gen_statem_SUITE.erl | 44 +++++++++++++++----------- 3 files changed, 102 insertions(+), 49 deletions(-) (limited to 'lib') diff --git a/lib/stdlib/doc/src/gen_statem.xml b/lib/stdlib/doc/src/gen_statem.xml index 9d98763973..f66f399137 100644 --- a/lib/stdlib/doc/src/gen_statem.xml +++ b/lib/stdlib/doc/src/gen_statem.xml @@ -475,8 +475,9 @@ erlang:'!' -----> Module:StateName/5 list order. This matters for next_event where the last one in the list will become the next event to present to the state functions. Regarding the other operations - it is only for {remove_event,EventPredicate} - that the order may matter. + it is only for remove_event with + EventPredicate + and for reply_operation() that the order may matter.

@@ -581,19 +582,6 @@ erlang:'!' -----> Module:StateName/5 Module:terminate/3 with Reason. - - - {next_state,StateOps} - - - The same as - - {next_state,State,StateData,StateOps} - but keeps the old State and StateData. - Believe it or not, but this one has actually - been proven useful to throw/1 from deep down - in the state logic. - {next_state,NewState,NewStateData} @@ -614,8 +602,47 @@ erlang:'!' -----> Module:StateName/5 The gen_statem will do a state transition to NewState - (which may be the same as State) - and execute all StateOps + (which may be the same as the current state) + and execute all StateOps + + + + {keep_state,NewStateData}} + + + The same as + + {keep_state,NewStateData,[]} + + + + + {keep_state,NewStateData,StateOps} + + + The gen_statem will keep the current state, or + do a state transition to the current state if you like, + and execute all StateOps + + + + {keep_state_and_data} + + + The same as + + {keep_state_and_data,[]} + + + + + {keep_state_and_data,StateOps} + + + The gen_statem will keep the current state, or + do a state transition to the current state if you like, + also keep the current state data, + and execute all StateOps diff --git a/lib/stdlib/src/gen_statem.erl b/lib/stdlib/src/gen_statem.erl index e03e22b087..3da4443f13 100644 --- a/lib/stdlib/src/gen_statem.erl +++ b/lib/stdlib/src/gen_statem.erl @@ -114,14 +114,20 @@ Reason :: term(), Replies :: [reply_operation()] | reply_operation(), NewStateData :: state_data()} | - {'next_state', % {next_state,State,StateData,StateOps} % Actually useful - StateOps :: [state_op()] | state_op()} | {'next_state', % {next_state,NewState,NewStateData,[]} NewState :: state(), NewStateData :: state_data()} | {'next_state', % State transition, maybe to the same state NewState :: state(), NewStateData :: state_data(), + StateOps :: [state_op()] | state_op()} | + {'keep_state', % {keep_state,NewStateData,[]} + NewStateData :: state_data()} | + {'keep_state', + NewStateData :: state_data(), + StateOps :: [state_op()] | state_op()} | + {'keep_state_and_data'} | % {keep_state_and_data,[]} + {'keep_state_and_data', StateOps :: [state_op()] | state_op()}. %% The state machine init function. It is called only once and @@ -477,7 +483,7 @@ enter(Module, Options, State, StateData, Server, InitOps, Parent) -> S#{callback_mode := CallbackMode}, [], {event,undefined}, % Will be discarded by {postpone,false} - State, StateData, + PrevState, State, StateData, StateOps++[{postpone,false}]); [Reason] -> ?TERMINATE(Reason, Debug, S, []) @@ -749,7 +755,10 @@ loop_events( end. %% Interpret all callback return value variants -loop_event_result(Parent, Debug, S, Events, Event, Result) -> +loop_event_result( + Parent, Debug, + #{state := State, state_data := StateData} = S, + Events, Event, Result) -> case Result of {stop,Reason} -> ?TERMINATE(Reason, Debug, S, [Event|Events]); @@ -775,28 +784,39 @@ loop_event_result(Parent, Debug, S, Events, Event, Result) -> ?TERMINATE( {bad_return_value,{stop,Reason,BadReplies,NewStateData}}, Debug, NewS, Q); - {next_state,StateOps} -> - #{state := State, state_data := StateData} = S, - loop_event_state_ops( - Parent, Debug, S, Events, Event, - State, StateData, StateOps); {next_state,NewState,NewStateData} -> loop_event_state_ops( Parent, Debug, S, Events, Event, - NewState, NewStateData, []); + State, NewState, NewStateData, []); {next_state,NewState,NewStateData,StateOps} when is_list(StateOps) -> loop_event_state_ops( Parent, Debug, S, Events, Event, - NewState, NewStateData, StateOps); + State, NewState, NewStateData, StateOps); + {keep_state,NewStateData} -> + loop_event_state_ops( + Parent, Debug, S, Events, Event, + State, State, NewStateData, []); + {keep_state,NewStateData,StateOps} -> + loop_event_state_ops( + Parent, Debug, S, Events, Event, + State, State, NewStateData, StateOps); + {keep_state_and_data} -> + loop_event_state_ops( + Parent, Debug, S, Events, Event, + State, State, StateData, []); + {keep_state_and_data,StateOps} -> + loop_event_state_ops( + Parent, Debug, S, Events, Event, + State, State, StateData, StateOps); _ -> ?TERMINATE( {bad_return_value,Result}, Debug, S, [Event|Events]) end. loop_event_state_ops( - Parent, Debug0, #{state := State, postponed := P0} = S, Events, Event, - NewState, NewStateData, StateOps) -> + Parent, Debug0, #{postponed := P0} = S, Events, Event, + State, NewState, NewStateData, StateOps) -> case collect_state_options(StateOps) of {Postpone,Hibernate,Timeout,Operations} -> P1 = % Move current event to postponed if Postpone diff --git a/lib/stdlib/test/gen_statem_SUITE.erl b/lib/stdlib/test/gen_statem_SUITE.erl index 6249ada027..92dc59e843 100644 --- a/lib/stdlib/test/gen_statem_SUITE.erl +++ b/lib/stdlib/test/gen_statem_SUITE.erl @@ -1158,10 +1158,10 @@ idle(cast, badreturn, _, _, _Data) -> badreturn; idle({call,_From}, badreturn, _, _, _Data) -> badreturn; -idle({call,From}, {delayed_answer,T}, _, _, _) -> +idle({call,From}, {delayed_answer,T}, _, _, Data) -> receive after T -> - throw({next_state,{reply,From,delayed}}) + throw({keep_state,Data,{reply,From,delayed}}) end; idle({call,From}, {timeout,Time}, _, State, _Data) -> {next_state,timeout,{From,Time}, @@ -1171,7 +1171,7 @@ idle(Type, Content, PrevState, State, Data) -> undefined -> case Type of {call,From} -> - throw({next_state,[{reply,From,'eh?'}]}); + throw({keep_state,Data,[{reply,From,'eh?'}]}); _ -> throw( {stop,{unexpected,State,PrevState,Type,Content}}) @@ -1209,7 +1209,7 @@ wfor_conf({call,From}, confirm, _, _, Data) -> {next_state,connected,Data, [{reply,From,yes}]}; wfor_conf(cast, {ping,_,_}, _, _, _) -> - {next_state,[postpone]}; + {keep_state_and_data,[postpone]}; wfor_conf(cast, confirm, _, _, Data) -> {next_state,connected,Data}; wfor_conf(Type, Content, PrevState, State, Data) -> @@ -1220,7 +1220,7 @@ wfor_conf(Type, Content, PrevState, State, Data) -> {next_state,idle,Data, [{reply,From,'eh?'}]}; _ -> - throw({next_state,[]}) + throw({keep_state_and_data}) end; Result -> Result @@ -1341,26 +1341,32 @@ handle_common_events(_, _, _, _, _) -> %% states. Note that the state from init/1 is not wrapped %% so both atom and non-atom states are tested. handle_event(Type, Event, PrevState, State, Data) -> - PrevStateName = unwrap(PrevState), - StateName = unwrap(State), - case - ?MODULE:StateName( + PrevStateName = unwrap_state(PrevState), + StateName = unwrap_state(State), + try ?MODULE:StateName( Type, Event, PrevStateName, StateName, Data) of - {next_state,NewState,NewStateData} -> - {next_state,wrap(NewState),NewStateData}; - {next_state,NewState,NewStateData,StateOps} -> - {next_state,wrap(NewState),NewStateData,StateOps}; - Other -> - Other + Result -> + wrap_result(Result) + catch + throw:Result -> + erlang:raise( + throw, wrap_result(Result), erlang:get_stacktrace()) end. -unwrap([State]) -> +unwrap_state([State]) -> State; -unwrap(State) -> +unwrap_state(State) -> State. -wrap(State) -> - [State]. +wrap_result(Result) -> + case Result of + {next_state,NewState,NewStateData} -> + {next_state,[NewState],NewStateData}; + {next_state,NewState,NewStateData,StateOps} -> + {next_state,[NewState],NewStateData,StateOps}; + Other -> + Other + end. -- cgit v1.2.3