LacteApp.hpp

Go to the documentation of this file.

#pragma once
 
#include <memory>
#include <optional>
#include <runtime/runtime.hpp>
#include <string>
#include <utility>
 
#include "AppContext.h"
#include "AppDb.hpp"
#include "AppRuntime.hpp"
#include "BoardModel.h"
#include "ConsoleApp.hpp"
#include "Logger.hpp"
#include "SystemState.hpp"
#include "bus/ModelBusClient.hpp"
#include "bus/UiBusClient.hpp"
#include "cm_protocol.hpp"
#include "libraries/interfaces/UartLinux.hpp"
#include "protocols/lacte/VirtualBoard.hpp"
#include "sqlite_bus_adapter.hpp"
#include "ui/UiApp.hpp"
 
// Обращённая к шине сторона m_storage_ (см. собственный файловый
// doc-комментарий AppDb.hpp о том, почему сам ThreadSafeDB/AppDb вообще
// ничего не знает о шине) - здесь список Meta прописан явно, вместо того
// чтобы переиспользовать его из AppDb::Base, поскольку SqliteBusAdapter<
// Meta...> - это совершенно другой шаблон (нет способа повторно применить
// вариативный пакет, извлечённый из одного шаблона класса, как список
// аргументов другого, без механики более сложной, чем оправдывают четыре
// повторяющихся имени типа).
using AppDbBusAdapter = insitech::database::SqliteBusAdapter<
    insitech::database::meta::StatMeta,
    insitech::database::meta::ServiceInfoMeta,
    insitech::database::meta::ErrorsMeta,
    insitech::database::meta::DictionaryMeta>;
 
// Конкретная инстанциация Runtime<RuntimeFields>, которой владеет это
// приложение (см. собственный accessor runtime() ConsoleApp ниже, который
// разрешается ровно в этот тип, поскольку LacteApp указывает RuntimeFields
// как собственный аргумент шаблона ConsoleApp'а RuntimeFieldsTuple - см.
// собственный doc-комментарий @tparam в ConsoleApp.hpp). Самому LacteApp
// никогда не нужно явно прописывать этот алиас - он просто вызывает
// runtime(). Он существует исключительно для кода, которому нужно назвать/
// сконструировать такой объект напрямую, не повторяя полную инстанциацию
// шаблона - а именно для LacteApp/tests/BoardModelTest.cpp, который
// подключает собственный LacteRuntime к BoardModel::OnUpdate() так же, как
// это делает конструктор этого приложения (см. LacteApp.cpp).
using LacteRuntime = insitech::runtime::Runtime<RuntimeFields>;
 
// Оболочка приложения — тонкий связующий слой, а не место, где живёт
// продуктовая логика. Вся её работа сводится к следующему:
//   * разобрать командную строку (см. опции m_app в конструкторе) и
//     превратить флаги в решения: виртуальная плата или реальная, какую
//     прошивку заливать, какой UI поднимать (--ui), тестовые режимы;
//   * владеть ресурсами уровня процесса и передавать их частям, которые
//     выполняют работу — она настраивает BoardModel (интерфейсы/виртуальная
//     плата) и подключает шинный транспорт UI/БД, затем запускает цикл
//     обновления;
//   * служить точкой, через которую тестовый набор управляет приложением
//     (он конструирует LacteApp с заранее заданными аргументами, путём к БД
//     и входным потоком — см. LacteApp/tests);
//   * самостоятельно реализовывать `ModelBusHandler` (health/param/snapshot/
//     rfid - см. `bus/ModelBusClient.hpp`), напрямую из результата опроса
//     BoardModel плюс собственного `runtime()` (см. базовый класс
//     ConsoleApp) - раньше это было задачей BoardModel; теперь BoardModel
//     вообще ничего не знает о шине (см. собственный файловый
//     doc-комментарий BoardModel.h), только о самой плате.
// Шинный транспорт (см. собственный AppContext в
// Libraries/app_control/AppContext.h - multicast-интерфейс открывается и
// подключается к шине на этапе сборки контекста, ещё до первого вызова
// Instance() - самому LacteApp здесь делать нечего) живёт в insitech::bus
// (AppContext::bus - см. ConsoleApp::m_context_ - строится тем, кто вызывает
// Instance()), доменный протокол - в cm_protocol.
class LacteApp final
    : public insitech::ConsoleApp<LacteApp, insitech::DefaultTerminationReasons,
                                  RuntimeFields>,
      public lacte::bus::ModelBusHandler {
 public:
  // Раньше host_rx_buffer/host_tx_buffer жили здесь и передавались в
  // BoardModel как аргументы шаблона - теперь это собственные статические
  // члены BoardModel (см. BoardModel::host_rx_buffer/host_tx_buffer в
  // BoardModel.h), поскольку экземпляр всегда только один. VirtualBoard
  // теперь так же владеет собственными буферами rx/tx (см.
  // protocols/lacte/VirtualBoard.hpp) - здесь тоже нечего объявлять или
  // передавать.
  proto::interface::UartLinuxInterface m_uart_interface;
  // HMI UART - совершенно отдельная физическая плата (управления
  // кофемашиной), не lacte-плата (см. m_uart_interface выше) - открывается
  // в run_impl(), только когда реально присутствует устройство (см.
  // lacte::ui::hmi_interface_available()), напрямую в этом приложении, а
  // не в каком-либо конкретном UI - см. собственный doc-комментарий
  // m_system_state_/m_hmi_protocol_ ниже о том, почему.
  proto::interface::UartLinuxInterface m_hmi_uart_interface;
  // Один буфер на приём/передачу HMI-протокола (см. m_hmi_protocol_ ниже) -
  // inline static член класса, а не namespace-scope переменная в .cpp (как
  // было у hmi_tx_buffer в старой версии FramebufferUi.cpp), по той же
  // причине, что и у BoardModel::host_rx_buffer/host_tx_buffer
  // (BoardModel.h) - нужен адрес с внешней связностью для нетипового
  // шаблонного параметра BackBoardProtocol, а экземпляр LacteApp на
  // процесс всегда ровно один.
  // NOLINTBEGIN(modernize-avoid-c-arrays)
  static constexpr std::size_t K_HMI_TX_BUFFER_SIZE = 300;
  inline static uint8_t hmi_tx_buffer[K_HMI_TX_BUFFER_SIZE]{};
  // NOLINTEND(modernize-avoid-c-arrays)
  proto::back_board_proto::BackBoardProtocol<hmi_tx_buffer, hmi_tx_buffer>
      m_hmi_protocol_;
  // Совмещённое состояние системы (online lacte-платы + HMI-сигнал двери,
  // см. собственный doc-комментарий SystemState.hpp) - отдельный объект, а
  // не логика внутри какого-либо конкретного UI: ни один UI не должен
  // ничего знать о HMI-протоколе вообще, только получать команду
  // enable/disable по шине (см. run_impl(), обработчик m_hmi_protocol_ -
  // публикует через m_ui_notifier_->set_ui_enabled(), тем же каналом
  // UiCommand, которым уже пользуется отключение UI при обрыве связи с
  // платой, см. runtime().on<BoardOnlineStatus>() в конструкторе). Оба UI
  // (framebuffer и консольный) видят текущий system_state и через
  // BoardSnapshot (см. BuildSnapshot()), для отображения/диагностики.
  // SetDoorSignalLostForTests() ниже позволяет тестам задавать
  // HMI-половину напрямую, без дублёра HMI-протокола - см. собственный
  // doc-комментарий SystemState.hpp о том, почему это вообще возможно
  // (чистая таблица истинности из двух bool).
  lacte::SystemStateResolver m_system_state_;
  // СОБСТВЕННЫЙ именованный Client этого приложения - каждый модуль
  // логирует через такой клиент (см. собственное правило
  // ConsoleApp/insitech::Logger), а не напрямую через m_context_.logger,
  // чтобы сообщения самого LacteApp тоже были видны как события шины
  // log.entry/log.line, помеченные тегом "[<app_name>]", так же как у
  // BoardModel ("[model]"). Объявлен ПЕРЕД m_board_model_ (инициализируется
  // первым в списке инициализации конструктора) исключительно по
  // соглашению - реальной зависимости между ними нет.
  std::shared_ptr<insitech::LoggerBusClient> m_client_;
  // Самим кэшем/диспетчеризацией платы runtime владеет базовый класс
  // ConsoleApp выше (его собственный m_runtime_, доступный через runtime()
  // - см. собственный doc-комментарий @tparam RuntimeFieldsTuple в
  // ConsoleApp.hpp; LacteApp указывает RuntimeFields как этот аргумент
  // шаблона, поэтому сам никогда не объявляет соответствующий член, не
  // разрешает путь кэша и не регистрирует callback сброса) - это
  // приложение также регистрирует на нём обработчики записи в БД для
  // отдельных полей напрямую (см. конструктор, заменяющий старый
  // DbRowRouter, работавший через шину), а также callback OnUpdate() на
  // m_board_model_ ниже, который проталкивает собственные показания
  // BoardModel в этот runtime (см. собственный файловый doc-комментарий
  // BoardModel.h о том, почему сам BoardModel никогда не трогает runtime()).
  BoardModel m_board_model_;
  // Виртуальная плата — тестовая/девелоперская замена реальной платы; её
  // дело, как и дело BoardModel, — это просто набор интерфейсов (см.
  // AttachVirtualBoard). Сам BoardModel ничего не знает о VirtualBoard.
  std::unique_ptr<proto::lacte::VirtualBoard> m_virtual_board;
 
  proto::back_board_proto::HeadPacketTypes last_packet_{};
  proto::back_board_proto::HeadFlags last_flags_{};
 
  friend ConsoleApp;
  // Сам ConsoleApp::instance() унаследован от AppShell (см. собственный
  // файловый doc-комментарий ConsoleApp.hpp) - именно код AppShell реально
  // конструирует LacteApp, поэтому ему это тоже нужно.
  friend insitech::AppShell<LacteApp, insitech::DefaultTerminationReasons,
                            RuntimeFields>;
 
  // Только для тестов: LacteApp::Instance() — это синглтон на весь процесс,
  // а CLI11 не сбрасывает привязанный к опции член обратно в значение по
  // умолчанию, если последующий вызов App::parse() просто не указывает эту
  // опцию (член сохраняет то значение, которое установил ПРЕДЫДУЩИЙ вызов
  // Run() - см. комментарий к virtual_args в LacteApp/tests/
  // LacteAppTest.cpp). ResetTestModeForTests() позволяет тестовому набору
  // напрямую очищать m_args_.test_mode между телами TEST_F, вместо борьбы
  // с CLI11 за невыразимое значение --test "явно пустая строка".
  void reset_test_mode_for_tests() { m_args_.test_mode.clear(); }
 
  // Только для тестов, та же логика, что и у ResetTestModeForTests() выше:
  // Instance() учитывает свой аргумент конструктора bin_path только при
  // самом первом вызове за весь процесс — каждый последующий вызов (какой
  // бы TEST_F ни оказался там первым) просто возвращает уже построенный
  // синглтон, молча игнорируя другой bin_path, переданный в более поздний
  // вызов Instance(). Тест, которому нужен конкретный bin_path и который
  // не может положиться на разбор --bin-path (например, если он ни разу
  // не перепарсивает аргументы CLI), устанавливает его напрямую здесь,
  // вместо борьбы с синглтоном через конструктор.
  void set_bin_path_for_tests(std::string path) {
    m_args_.bin_path = std::move(path);
  }
 
  auto get_bin_path() const -> std::string { return m_args_.bin_path; }
 
  // Только для тестов, та же логика, что и у SetBinPathForTests() выше:
  // теперь run_impl() разрешает db_path напрямую из m_context_.config
  // (kAppDir/kDbName) - единственного источника истины, а не аргумента,
  // переданного вызывающим кодом. Тесту, которому нужен собственный файл
  // БД на каждый TEST_F (конфигурация общего g_test_app_context фиксирована
  // на весь бинарник), проще установить его напрямую здесь, чем
  // пересобирать целиком config/AppContext ради переопределения одного
  // поля.
  void set_db_path_for_tests(std::string path) {
    m_db_path_override_ = std::move(path);
  }
 
  // Только для тестов: задаёт HMI-половину SystemState напрямую, минуя
  // реальный HMI UART/BackBoardProtocol - см. собственный doc-комментарий
  // SystemStateResolver в SystemState.hpp о том, почему это вообще
  // корректно (чистая таблица истинности из двух bool, ей всё равно,
  // откуда пришёл каждый из них). Идёт через тот же ApplyDoorSignal(), что
  // и реальный HMI-колбэк (run_impl()) - тест упражняет и пересчёт
  // m_system_state_, и публикацию UiCommand через m_ui_notifier_, а не
  // только первое.
  void set_door_signal_lost_for_tests(const bool lost) {
    apply_door_signal(lost);
  }
 
  auto run_impl(std::istream& input = std::cin) -> int;
 
  void stop() {
    m_running = false;
    m_cv.notify_all();
  }

  [[nodiscard]] auto get_bus() const -> lacte::bus::ModelBusClient* {
    return m_bus_.get();
  }
 
 private:
  // Создаёт виртуальную плату (тестовую/девелоперскую замену реального
  // оборудования) и подключает её интерфейсы к BoardModel — BoardModel
  // видит только интерфейсы и никогда не узнаёт о существовании
  // виртуальной платы. Используется только в режиме --virtual.
  void attach_virtual_board();
 
  // Строит и владеет СОБСТВЕННЫМИ клиентами этого приложения на `ctx.bus`
  // — LacteApp сам строит только ОДИН общий узел шины (см.
  // AppContext::bus); каждый участник (раньше это делал BoardModel, теперь
  // UI, БД) строит собственного клиента (или клиентов) поверх него и сам
  // подключает на нём свой протокол, вместо того чтобы получать уже
  // готовые. Немедленно обслуживает темы запросов шины через
  // ServeModel(*this) - теперь именно LacteApp реализует ModelBusHandler
  // (см. doc-комментарий класса). Строит ДВУХ клиентов: `m_bus_`
  // (ModelBusClient, для ServeModel()) и `m_ui_notifier_` (UiBusClient,
  // исключительно для отправки UiCommand/BoardSnapshotEvent - это знание о
  // протоколе UI, поэтому оно живёт в UiBusClient, а не здесь - см.
  // файловый doc-комментарий UiBusClient.hpp).
  void connect_bus(const AppContext& ctx, uint32_t address,
                   const std::string& name, uint32_t ui_notifier_address);
 
  // Пересчитывает m_system_state_ из нового HMI-сигнала двери и, если уже
  // подключена шина (m_ui_notifier_), публикует итог как UiCommand - см.
  // собственный doc-комментарий .cpp-определения о том, почему это общая
  // точка входа для реального HMI-колбэка И SetDoorSignalLostForTests().
  void apply_door_signal(bool door_signal_lost);
 
  // Шинный клиент, на котором это приложение обслуживает запросы
  // ModelBusHandler, построенный и принадлежащий самому приложению (см.
  // ConnectBus()) - реализует контракт ModelBusHandler, обслуживается
  // через m_bus_->ServeModel(*this).
  std::shared_ptr<lacte::bus::ModelBusClient> m_bus_;
 
  // Второй клиент, исключительно для отправки UiCommand/BoardSnapshotEvent
  // в UI (например, DisableUi() при изменении состояния платы - см.
  // собственную регистрацию конструктора runtime().on<BoardOnlineStatus>())
  // - это UiBusClient, а не ModelBusClient, поскольку это знание о
  // протоколе UI (см. файловый doc-комментарий UiBusClient.hpp о причине).
  // Нужен собственный, отличный от других, адрес шины - один клиент не
  // может быть зарегистрирован на двух адресах сразу.
  //
  // m_ui_notifier_mx_ защищает КАЖДОЕ обращение к m_ui_notifier_ (чтение
  // И запись, включая обнуление в teardown run_impl()) - без этого
  // `if (m_ui_notifier_) { m_ui_notifier_->...(); }` в apply_door_signal()
  // и в runtime().on<BoardOnlineStatus>() ниже гонится с main-потоком:
  // apply_door_signal() вызывается с ФОНОВОГО потока m_hmi_protocol_ (см.
  // ProtocolEndpoint::m_deque_thread в protolib - живёт всю жизнь
  // LacteApp, никогда не останавливается на время teardown одного
  // run_impl()), а on<BoardOnlineStatus> - с потока BoardModel::Worker().
  // Оба могут сработать РОВНО в момент, когда run_impl() делает
  // `m_ui_notifier_ = nullptr;` - проверка "не nullptr" сама по себе не
  // синхронизирована с этим присваиванием, значит между проверкой и
  // вызовом `->...()` объект может быть уже разрушен. Воспроизведено
  // вживую на реальной плате: один и тот же паттерн ("после lacte model
  // stopped") давал то SIGSEGV, то std::terminate() без исключения в
  // полёте (мусорный vtable через уже освобождённую память) - разные
  // симптомы одной и той же гонки, не два разных бага.
  mutable std::mutex m_ui_notifier_mx_;
  std::shared_ptr<lacte::bus::UiBusClient> m_ui_notifier_;
 
  // Гейт teardown: run_impl() выставляет его в true ПЕРВЫМ действием
  // своего teardown-блока, до единого reset()/nullptr - m_ui_.reset(),
  // m_board_model_.stop() и всё, что идёт следом, ещё даже не начинались.
  // Каждый обработчик, вызываемый с чужого потока и трогающий что-либо из
  // teardown (m_storage_ в runtime().on<InfoPacketType>()/
  // <BoardErrorDiff>()/on_unhandled(), m_ui_notifier_ в
  // apply_door_signal()/on<BoardOnlineStatus>() - см. их собственные
  // doc-комментарии) проверяет этот флаг ПЕРВОЙ строкой и молча
  // выходит, если teardown уже начался - вместо того чтобы у каждого
  // такого поля по отдельности заводить свой mutex (m_ui_notifier_mx_
  // выше - именно такая точечная защита, оставлена как есть: сама по
  // себе она уже полная гарантия для ЭТОГО одного поля, но не
  // масштабируется на каждое новое поле, которое когда-либо понадобится
  // читать из BoardModel::Worker()/m_hmi_protocol_'а). Не устраняет гонку
  // формально (проверка флага и использование объекта - всё ещё два
  // отдельных шага), но сокращает окно с "весь teardown" до "несколько
  // инструкций между этим store() и первым reset()" - на практике этого
  // достаточно, поскольку любой обработчик, уже начавший выполняться до
  // set(true), либо успевает завершиться в этом крошечном окне, либо
  // (для m_ui_notifier_ конкретно) всё равно защищён m_ui_notifier_mx_
  // выше. Сбрасывается обратно в false в начале run_impl() - тот же
  // экземпляр LacteApp может пережить несколько вызовов run_impl() (см.
  // собственный комментарий об этом в teardown-блоке run_impl()).
  std::atomic_bool m_tearing_down_{false};
 
  // Контракт ModelBusHandler (см. bus/ModelBusClient.hpp) - это приложение
  // реализует его напрямую из состояния m_board_model_ (health/param) и
  // собственного runtime() (snapshot через BuildSnapshot(), rfid через
  // GetRfidData() ниже) - раньше это было задачей BoardModel; теперь
  // BoardModel вообще ничего не знает о шине.
  auto health() -> bool override {
    return m_board_model_.is_running() && m_board_model_.is_online();
  }
 
  auto get_param(const std::string& param) -> std::optional<int> override {
    if (param == lacte::bus::K_PARAM_AERATION) {
      return m_board_model_.get_aeration();
    }
    return std::nullopt;
  }
 
  auto set_param(const std::string& param, const int value) -> bool override {
    if (param != lacte::bus::K_PARAM_AERATION) {
      return false;
    }
    return m_board_model_.set_aeration(static_cast<uint8_t>(value));
  }
 
  // Отвечает на шинный запрос снапшота напрямую из runtime() - само
  // отображение см. в определении .cpp. Без отдельной косвенности
  // безаргументного BuildSnapshot() - это был единственный её вызывающий,
  // помимо GetRfidData() ниже, которая уже напрямую берёт перегрузку с
  // BoardData.
  auto get_snapshot() -> lacte::bus::BoardSnapshot override {
    return build_snapshot(runtime().current());
  }
 
  // Отвечает на шинный запрос данных RFID напрямую из runtime() - само
  // отображение см. в определении .cpp (собственный doc-комментарий
  // RfidData объясняет, почему это отдельно от BuildSnapshot()/
  // GetSnapshot()). Без отдельной косвенности BuildRfidData() - это был
  // единственный её вызывающий.
  auto get_rfid_data() -> lacte::bus::RfidData override;
 
  // Отображает показание board_state (см. собственный doc-комментарий
  // BoardData) на проводной тип снапшота (перенесено из BoardModel - см.
  // собственный файловый doc-комментарий BoardModel.h). Чистое
  // отображение, без собственного ввода-вывода - оба вызывающих
  // (GetSnapshot() выше и GetRfidData() ниже, которой нужен тот же самый
  // фильтр по error_flags) сами получают runtime().current() и передают
  // его сюда, так что вызывающий, у которого уже есть показание, никогда
  // не вызывает второй, независимый вызов runtime().current() мгновением
  // позже (два отдельных чтения, гоняющихся с любым параллельным Set() -
  // именно этот баг раньше здесь и был).
  auto build_snapshot(const BoardData& board_state) const
      -> lacte::bus::BoardSnapshot;
 
  // Каждое поле, которое становится аргументом командной строки,
  // привязанным через CLI11 (см. вызовы m_app.add_option()/add_flag() в
  // конструкторе), сгруппировано в одну структуру исключительно для того,
  // чтобы собственный список членов LacteApp не превратился в восемь
  // отдельных разрозненных полей - CLI11 привязывается напрямую к каждому
  // полю здесь, точно так же, как к самостоятельному члену.
  struct Args {
    std::string test_mode;
    std::string flash_path;
    std::string device_name;
    std::chrono::milliseconds check_update_interval{};
    std::string bin_path;
    bool virtual_mode{false};
    // Режим UI, выбираемый через --ui: "fb" (framebuffer, по умолчанию),
    // "console" или "no". Устанавливается из m_context_.config (к этому
    // моменту уже загруженного — см. комментарий в конструкторе) в теле
    // конструктора, до того как CLI11 регистрирует опцию.
    std::string ui_mode;
    // Минимальная серьёзность, записываемая в лог (0=INFO, 1=WARNING,
    // 2=ERROR) - по умолчанию берётся из log_min_level конфигурации (см.
    // AppConfig.hpp), --log-level переопределяет её. Применяется через
    // m_context_.logger.set_level() в самом начале run_impl(), как только
    // CLI11 реально разобрал argv (собственный конструктор AppContext уже
    // применил значение по умолчанию, взятое только из конфигурации, ранее
    // - до того как какая-либо CLI-опция могла бы его переопределить - см.
    // AppContext.h).
    int64_t log_min_level{};
  };
 
  Args m_args_;
 
  // Переопределение только для тестов для разрешения db_path в run_impl()
  // - см. собственный doc-комментарий SetDbPathForTests(). Пустая строка
  // (значение по умолчанию) означает "использовать вместо этого kAppDir/
  // kDbName из m_context_.config", точно как в реальном запуске.
  std::string m_db_path_override_;
 
  // Хранилище данных платы — напрямую сгенерированный кодогенератором
  // AppDb (см. AppDb.hpp). shared_ptr (а не простой член), сконструирован
  // через конструктор без шины и затем подключён к m_shared_bus_ через
  // собственный ConnectExternalClient() у m_storage_bus_ (см. run_impl())
  // - тот подписывается через weak_ptr на этот объект, а не через
  // "голый" `this` (см. doc-комментарий
  // SqliteBusAdapter::ConnectExternalClient()), так что порядок
  // разрушения между m_storage_ и его клиентом не нужно проверять вручную:
  // сообщение, пришедшее после того как m_storage_ уже уничтожен, просто
  // ничего не делает. Собственные обработчики on<Field>()/on_unhandled()
  // у m_runtime_ (регистрируются в run_impl(), сразу после построения
  // этого объекта) пишут строки, на которые подписана эта БД, в рамках
  // процесса - без кругового обхода через шину (раньше это делал
  // DbRowRouter).
  std::shared_ptr<AppDb> m_storage_;
  // Обращённая к шине сторона m_storage_ (см. AppDb.hpp - сам AppDb/
  // ThreadSafeDB вообще ничего не знает о шине) - optional (а не простой
  // член), поскольку может быть сконструирован только тогда, когда
  // m_storage_ уже существует, оба строятся вместе в run_impl(). Объявлен
  // после m_storage_, чтобы разрушаться первым при остановке (прекратить
  // использовать клиента раньше, чем уничтожается то, на что он указывает
  // - не требование корректности, учитывая подписку через weak_ptr выше,
  // просто более разумный порядок).
  std::optional<AppDbBusAdapter> m_storage_bus_;
 
  // UI, если он был запущен (--ui и присутствуют его устройства). Работает
  // в собственном потоке и управляется по RAII — его сброс (при остановке)
  // останавливает и присоединяет (join) этот поток.
  std::unique_ptr<lacte::ui::UiApp> m_ui_;
 
  // std::ostream &cout_;
  std::mutex m_stop_mx_;
  std::mutex m_gui_mx_;
  // std::condition_variable stop_cv_;
  explicit LacteApp(AppContext& ctx, const std::string& bin_path = "");
 
  ~LacteApp() override = default;
 
  void user_signal_handler(int signum) override;
 
  void try_to_update();
 
  // Заполняет/обновляет справочную таблицу "dictionary" в m_storage_
  // (названия статусов + описания ошибок платы), чтобы она всегда была
  // синхронизирована с текущей сборкой, без каких-либо ручных шагов над БД
  // — общий механизм сравнения/перезаписи, который для этого используется,
  // см. в ThreadSafeDB::sync_table() в Libraries/sqlite/sqlite.hpp.
  // Вызывается один раз, сразу после конструирования m_storage_ (см.
  // run_impl).
  void ensure_dictionary_up_to_date() const;
 
  void ping_test(std::istream& cin, std::ostream& cout);
};