Передача данных между потоками с помощью boost.signals2

Question

Я прошу прощения за неоднозначное название, но я постараюсь уточнить здесь:

У меня есть приложение, которое включает (среди прочего) элемент управления и классы TCP-сервера. Связь между TCP и классом управления осуществляется через эту реализацию:

#include <boost/signals2.hpp>                                                                        

// T - Observable object type                                                                        
// S - Function signature                                                                            
template <class T, typename S> class observer {                                                      
        using F = std::function<S>;                                                                  

      public:                                                                                        
        void register_notifier(T &obj, F f)                                                          
        {                                                                                            
                connection_ = obj.connect_notifier(std::forward<F>(f));                              
        }                                                                                            

      protected:                                                                                     
        boost::signals2::scoped_connection connection_;                                              
};                                                                                                   

// S - Function signature                                                                            
template <typename S> class observable {                                                             
      public:                                                                                        
        boost::signals2::scoped_connection connect_notifier(std::function<S> f)                      
        {                                                                                            
                return notify.connect(std::move(f));                                                 
        }                                                                                            

      protected:                                                                                     
        boost::signals2::signal<S> notify;                                                           
};

Где класс сервера TCP является наблюдаемым, а класс управления - наблюдателем.

Сервер TCP работает в отдельном потоке от класса управления и использует boost :: asio :: async_read. Всякий раз, когда сообщение принимается, объект сервера отправляет уведомление через член «notify», вызывая тем самым обратный вызов, зарегистрированный в классе управления, и затем ожидает прочтения следующего сообщения.

Проблема в том, что мне нужно каким-то образом безопасно и эффективно сохранить данные, которые в данный момент хранятся в буфере TCP-сервера, и передать их классу управления, прежде чем они будут переопределены следующим сообщением.

т.е. :

inline void ctl::tcp::server::handle_data_read(/* ... */)                                  
{                                                                                                    
        if (!error) {                                                                                 
                /* .... */
                notify(/* ? */); // Using a pointer to the buffer
                                 // would obviously fail as it
                                 // is overridden in the next read                    
        }
        /* .... */                                                                                            
}

До сих пор это были мои идеи для решения:

1. Выделение памяти кучи и передача указателя на нее с помощью unique_ptr, но я не уверен, что boost.signals2 учитывает движение.
2. Используйте неупорядоченная карта (совместно используемая объектами), которая отображает целочисленный индекс в unique_ptr тип данных (std::unordered_map<int, std::unique_ptr<data_type>>), затем только передайте индекс элемента и вставьте его в элемент управления обратный вызов класса, но это похоже на излишество.

Что мне действительно нужно, так это идея простого и эффективного решения для передачи содержимого буфера TCP для каждого сообщения между потоками.

Примечание Я также открыт для предложений по изменению моего метода связи между объектами, если он полностью неверен.