FactoryVecDeque will eventually crash due to memory leaks about relm4 HOT 7 OPEN

use gtk::prelude::*;
use item::Item;
use relm4::{
  factory::{FactoryComponent, FactoryVecDeque, FactoryView},
  gtk,
  prelude::*,
  FactorySender,
};
use std::time::Duration;

fn main() {
  gtk::init().unwrap();
  let app = relm4::main_application();

  RelmApp::from_app(app).run::<List>(());
}

pub struct List {
  items: FactoryVecDeque<Item>,
}

#[derive(Debug)]
pub enum ListInput {
  Update,
}

impl SimpleComponent for List {
  type Init = ();
  type Input = ListInput;
  type Output = ();
  type Root = gtk::ApplicationWindow;
  type Widgets = ();

  fn init_root() -> Self::Root {
    gtk::ApplicationWindow::builder().build()
  }

  fn init(
    _init: Self::Init,
    root: Self::Root,
    sender: ComponentSender<Self>,
  ) -> ComponentParts<Self> {
    let list = gtk::Box::builder().build();
    root.set_child(Some(&{
      let container = gtk::ScrolledWindow::builder().build();
      container.set_child(Some(&list));
      container
    }));
    let items = FactoryVecDeque::builder().launch(list).detach();
    let model = Self { items };
    std::thread::spawn({
      let sender = sender.clone();
      move || loop {
        sender.input(ListInput::Update);
        std::thread::sleep(Duration::from_secs(1));
      }
    });
    ComponentParts { widgets: (), model }
  }

  fn update(&mut self, message: Self::Input, _sender: ComponentSender<Self>) {
    match message {
      ListInput::Update => {
        let mut guard = self.items.guard();
        guard.clear();
        for _ in 0..10000 {
          guard.push_back(Item {});
        }
      }
    }
  }
}

mod item {
  use super::*;

  #[derive(Clone)]
  pub struct Item;

  type RootWidget = gtk::Box;

  #[derive(Debug)]
  pub struct FactoryWidgets {}

  impl FactoryComponent for Item {
    type Init = Self;
    type Input = ();
    type Output = ();
    type CommandOutput = ();
    type ParentWidget = gtk::Box;
    type Root = RootWidget;
    type Widgets = FactoryWidgets;
    type Index = DynamicIndex;

    fn init_root(&self) -> Self::Root {
      RootWidget::builder()
        .hexpand(false)
        .vexpand(true)
        .halign(gtk::Align::Start)
        .build()
    }

    fn init_widgets(
      &mut self,
      _index: &DynamicIndex,
      _root_widget: Self::Root,
      _returned_widget: &<Self::ParentWidget as FactoryView>::ReturnedWidget,
      _sender: FactorySender<Self>,
    ) -> Self::Widgets {
      Self::Widgets {}
    }

    fn init_model(value: Self::Init, _index: &DynamicIndex, _sender: FactorySender<Self>) -> Self {
      value
    }
  }
}

use gtk::{prelude::*, Application, ApplicationWindow};
use relm4::{prelude::gtk, RelmRemoveAllExt};
use std::time::Duration;

fn main() {
  let application = Application::builder()
    .application_id("com.example.list")
    .build();

  application.connect_activate(|app| {
    let window = ApplicationWindow::builder()
      .application(app)
      .default_width(400)
      .default_height(400)
      .build();

    window.set_child(Some(&{
      let container = gtk::ScrolledWindow::builder().build();
      container.set_child(Some(&{
        let list = gtk::Box::builder().build();

        gtk::glib::timeout_add_local(Duration::from_secs(1), {
          let list = gtk::glib::clone::Downgrade::downgrade(&list);
          move || {
            let Some(list) = list.upgrade()
            else {
              return false.into();
            };

            list.remove_all();
            for _ in 0..10000 {
              list.append(&{ gtk::Box::builder().build() });
            }

            true.into()
          }
        });

        list
      }));
      container
    }));

    window.show();
  });

  application.run();
}