Order going out: (->OrderServiceServer -> ... EMNativeOrder -> ... -> EMExecutionGateway -> exchange)
----------------

OrderServiceServer::create_order (Create) ->
ServiceBridge::create_order(Create) ->
   publish(ActivateOrderEvent)
OrderManager::on_activate_order(const mercury::Update<ActivateOrderEvent> &) ->
OrderServices::activate ->
EMNativeOrder::on_activate (p, q, services) ->
OrderServices::queue_order_msg (CreateOrderMsg) ->
SessionServices::queue_order_msg(CreateOrderMsg) ->
   _session_data->buffered_order_msgs->emplace_back(OrderMsg{order_op}) ->

OrderManager has the handle to the same queue above (buffered_order_msgs)
In OrderManager::after_event it checks for messages and sends them to IExecutionGateway
(gw->send_msgs(queued_ops, osd->current_trace);)

EMExecutionGateway::send_msg(std::vector<OrderMsg> const &)
(this is where the order is actually sent out)

The above is a single chain (callstack maybe), but there are other components 
listening to events and acting


Callbacks coming in (exchange -> ... EMExecutionGateway ... -> EMNativeOrder .. -> OrderServiceServer)
--------------------

EMExecutionGateway::dispatch_incoming_fix_messages() ->
(EMExecutionGateway receives messages independently from the exchange and queues them,
in dispatch_incoming_fix_messages, it calls on_exe_report)

EMExecutionGateway::on_exe_report(ExecutionReport) ->
OrderManager::publish(mercury::Stream<NewExecutionReportEvent) ->

EMNativeOrder::_on_exe_report(const NewExecutionReportEvent &er) ->
EMNativeOrder::report_state() ->
OrderServices::report_state(OrderState) ->
OrderManager::publish(OrderStateUpdateEvent) ->
   through the event system
OrderStore::on_order_state_update(mercury::Update<OrderStateUpdateEvent> const &) ->
OrderStore::publish(StoredOrderEvent) ->
   through the event system
ServiceBridge::on(mercury::Update<StoredOrderEvent> const &) ->
OrderServiceServer::on_orders(OrderRecord)
(goes out to the client)

Persisting Orders:
-----------------
EMNativeOrder::report_state ->
OrderServices::report_state ->
OrderManager::publish(mercury::Stream<OrderStateUpdateEvent>) ->
   through the event system
OrderStore::on_order_state_update(mercury::Stream<OrderStateUpdateEvent>&)

Persisting Fills:
-----------------
FillStore::on_execution_report(const mercury::Update<NewExecutionReportEvent> &)

Order/ExecutionReport state:
---------------------------

IEMOrderMuxer::EMOrderState absorbs emumba::order_entry::order_state
ExecutionReport copies values directly from EMOrderState (no logic except to check trades)
EMNativeOrder::_absorb_fill checks for er.last_shares and copies fill values directly from ExecutionReport

RFQ:
----
OrderServiceServer::send_rfq ->
ServiceBridge::send_rfq ->
   publish(RFQEvent)
OrderManager::on_rfq_send (event callback) ->
IExecutionGateway::send_msgs  // iterates through all  of them
// for Deribit
EMExecutionGateway::send_msgs ->
EmMDListener::send_rfq

Misc:
-----
To search for a publisher for an event search for make_stream<Event_Name>, for 
example make_stream<OrderStateUpdateEvent>()


ALGO:
----
// last 3 steps before an algo gets a child order update

AlgoWrapperOrder::me->services->subscribe_to_child_updates
AlgoWrapperOrder::on_child_order_update
TaskingEyeAlgo::on_child_change