anchor.diff:        Message, State,
         {Options, Slowest, {BPs, true, tl(Queue), BPStepped, StepperPid}}, hd(Queue), FromQueue).
   
  +-spec handle_bp_request_in_bp(comm:message(), any(), component_state(),
  +                              bp_message(), boolean())
  +                             -> component_state().
   handle_bp_request_in_bp(Message, State, ComponentState, BPMsg, FromQueue) ->
       ?TRACE_BP("Handle bp request in bp ~p ~n", [BPMsg]),
       {Options, Slowest, BPState} = ComponentState,
  
positive.code:     {'$gen_component', [{on_handler, Handler}], State}.
  
  %% @doc perform a post op, i.e. handle a message directly after another
  -spec post_op(State, Message::comm:message())
          -> {'$gen_component', [{post_op, Message::comm:message()}], State}.
  post_op(State, Message) ->
      {'$gen_component', [{post_op, Message}], State}.
  
  %% requests regarding breakpoint processing
  -spec bp_set(Pid::comm:erl_local_pid(), MsgTag::comm:message_tag(), BPName::any()) -> ok.
  bp_set(Pid, MsgTag, BPName) ->
      Pid ! {'$gen_component', bp, bp_set, MsgTag, BPName},
      ok.
  
  %% @doc Module:Function(Message, State, Params) will be evaluated to decide
  %% whether a BP is reached. Params can be used as a payload.
  -spec bp_set_cond(Pid::comm:erl_local_pid(),
                    Cond::{module(), atom(), 2} | fun((comm:message(), State::any()) -> boolean()),
                    BPName::any()) -> ok.
  bp_set_cond(Pid, {_Module, _Function, _Params = 2} = Cond, BPName) ->
      Pid ! {'$gen_component', bp, bp_set_cond, Cond, BPName},
      ok;
  
negative.code:             {Module, On, Message}
      end.
  
  -spec bp_cont(pid()) -> ok.
  bp_cont(Pid) ->
      Pid !  {'$gen_component', bp, breakpoint, cont},
      ok.
  
  %% @doc delay further breakpoint requests until a breakpoint actually occurs
  -spec bp_barrier(pid()) -> ok.
  bp_barrier(Pid) ->
      Pid ! {'$gen_component', bp, barrier},
      ok.
  