compose-rt

A positional memoization runtime similar to Jetpack Compose Runtime.

example

Below example show how to build a declarative GUI using compose-rt

toml [dependencies] compose-rt = "0.3" downcast-rs = "1.2.0" log = "0.4" env_logger = "0.6" fake = "2.4"

```rust

![allow(nonsnakecase)]

use composert::{ComposeNode, Composer}; use downcastrs::{impl_downcast, Downcast}; use fake::{Fake, Faker}; use std::{ any::TypeId, cell::{RefCell, RefMut}, fmt::Debug, rc::Rc, };

//////////////////////////////////////////////////////////////////////////// // User application //////////////////////////////////////////////////////////////////////////// pub struct Movie { id: usize, name: String, imgurl: String, } impl Movie { pub fn new(id: usize, name: impl Into, imgurl: impl Into) -> Self { Movie { id, name: name.into(), imgurl: imgurl.into(), } } }

[track_caller]

pub fn MoviesScreen(cx: Context, movies: &Vec) { Column(cx, |cx| { for movie in movies { cx.tag(movie.id, |cx| MovieOverview(cx, &movie)) } }) }

[track_caller]

pub fn MovieOverview(cx: Context, movie: &Movie) { Column(cx, |cx| { Text(cx, &movie.name); Image(cx, &movie.img_url); RandomRenderObject(cx, &movie.name) }) }

fn main() { // Setup logging envlogger::Builder::fromdefaultenv() .filterlevel(log::LevelFilter::Trace) .init();

// define root compose
let root_fn = |cx: Context, movies| MoviesScreen(cx, movies);

let mut cx = Composer::new(10);

// first run
let movies = vec![Movie::new(1, "A", "IMG_A"), Movie::new(2, "B", "IMG_B")];
root_fn(&mut cx, &movies);

// end compose, Recomposer allow you to access root
let mut recomposer = cx.finalize();
if let Some(mut root) = recomposer.root_mut() {
    if let Some(render_obj) = root.cast_mut::<Rc<RefCell<RenderFlex>>>() {
        // call paint of render tree
        let mut context = PaintContext::new();
        render_obj.borrow().paint(&mut context);
    }
}

cx = recomposer.compose();
// rerun with new input
let movies = vec![
    Movie::new(1, "AA", "IMG_AA"),
    Movie::new(3, "C", "IMG_C"),
    Movie::new(2, "B", "IMG_B"),
];
root_fn(&mut cx, &movies);

// end compose, Recomposer allow you to access root
let mut recomposer = cx.finalize();
if let Some(mut root) = recomposer.root_mut() {
    if let Some(render_obj) = root.cast_mut::<Rc<RefCell<RenderFlex>>>() {
        // call paint of render tree
        let mut context = PaintContext::new();
        render_obj.borrow().paint(&mut context);
    }
}

}

//////////////////////////////////////////////////////////////////////////// // Components - Usage of compose-rt //////////////////////////////////////////////////////////////////////////// type Context<'a> = &'a mut Composer;

[track_caller]

pub fn Column(cx: Context, content: C) where C: Fn(Context), { cx.groupusechildren( || Rc::new(RefCell::new(RenderFlex::new())), |cx| content(cx), |node, children| { let mut flex = node.borrowmut(); flex.children.clear(); for child in children { if let Some(c) = child.downcastref::>>().cloned() { flex.children.push(c); } else if let Some(c) = child.downcastref::>>().cloned() { flex.children.push(c); } else if let Some(c) = child.downcastref::>>().cloned() { flex.children.push(c); } else if let Some(c) = child .downcastref::>>() .cloned() { flex.children.push(c); } } }, || false, || {}, ); }

[track_caller]

pub fn Text(cx: Context, text: impl AsRef) { let text = text.asref(); cx.memo( || Rc::new(RefCell::new(RenderLabel(text.tostring()))), |n| n.borrow().0 == text, |n| { let mut n = n.borrowmut(); n.0 = text.to_string(); }, ); }

[track_caller]

pub fn Image(cx: Context, url: impl AsRef) { let url = url.asref(); cx.memo( || Rc::new(RefCell::new(RenderImage(url.tostring()))), |n| n.borrow().0 == url, |n| { let mut n = n.borrowmut(); n.0 = url.to_string(); }, ); }

[track_caller]

pub fn RandomRenderObject(cx: Context, text: impl AsRef) { let t = text.asref(); cx.memo( || { let obj: Rc> = if Faker.fake::() { let url = format!("http://image.com/{}.png", t); Rc::new(RefCell::new(RenderImage(url))) } else { Rc::new(RefCell::new(RenderLabel(t.tostring()))) }; obj }, || false, |n| { let n = n.borrowmut(); let tyid = (*n).type_id();

        if ty_id == TypeId::of::<RenderLabel>() {
            let mut label = RefMut::map(n, |x| x.downcast_mut::<RenderLabel>().unwrap());
            label.0 = t.to_string();
        } else if ty_id == TypeId::of::<RenderImage>() {
            let mut img = RefMut::map(n, |x| x.downcast_mut::<RenderImage>().unwrap());
            let url = format!("http://image.com/{}.png", t);
            img.0 = url;
        };
    },
);

}

//////////////////////////////////////////////////////////////////////////// // Rendering backend - Not scope of compose-rt //////////////////////////////////////////////////////////////////////////// pub trait Node: Debug + Downcast + Unpin { fn debugprint(&self) {} } impldowncast!(Node);

impl Node for T {}

impl Into> for Rc> { fn into(self) -> Box { Box::new(self) } }

impl<'a> ComposeNode for &'a mut dyn Node { fn castmut(&mut self) -> Option<&mut T> { self.downcastmut::() } }

impl Into> for Rc> { fn into(self) -> Box { Box::new(self) } }

pub struct PaintContext { depth: usize, } impl PaintContext { pub fn new() -> Self { Self { depth: 0 } } }

pub trait RenderObject: Debug + Downcast { fn paint(&self, context: &mut PaintContext); } impl_downcast!(RenderObject);

[derive(Debug)]

pub struct RenderFlex { children: Vec>>, }

impl RenderFlex { pub fn new() -> Self { RenderFlex { children: Vec::new(), } } }

impl RenderObject for RenderFlex { fn paint(&self, context: &mut PaintContext) { println!( "{}", "\t".repeat(context.depth)); } }

[derive(Debug)]

pub struct RenderLabel(String); impl RenderObject for RenderLabel { fn paint(&self, context: &mut PaintContext) { println!("{}{}", "\t".repeat(context.depth), self.0); } }

[derive(Debug)]

pub struct RenderImage(String); impl RenderObject for RenderImage { fn paint(&self, context: &mut PaintContext) { println!("{}", "\t".repeat(context.depth), self.0); } } ```