Method get_sixel

src/content.rs:148–194

(&mut self, dim: NodeDim)

    }

    pub fn get_sixel(&mut self, dim: NodeDim) -> Option<Result<Sixel>> {
        let Node { sixel_cache, state, content, .. } = self;

        // first check the SIXEL blob cache
        if let Some(data) = (*sixel_cache.read().unwrap()).get(&dim) {
            return Some(Ok(data.clone()));
        }

        let state_cont = std::mem::replace(&mut *state.write().unwrap(), ContentState::Empty);

        let (res, state_cont) = match state_cont {
            ContentState::Empty => {
                let state_cloned = state.clone();
                let content = content.clone();
                thread::spawn(move || {
                    let res = content.1.generate(content.0);

                    *state_cloned.write().unwrap() = match res {
                        Ok(res) => ContentState::Ok(res),
                        Err(err) => ContentState::Err(err),
                    };
                });

                (None, ContentState::Running)
            },
            ContentState::Err(error) => 
                (Some(Err(error)), ContentState::Empty),
            ContentState::Ok(content) => {
                // start thread to calculate SIXEL blob
                let sixel_cache = sixel_cache.clone();
                let state = state.clone();

                thread::spawn(move || {
                    let res = content.clone().wand_to_sixel(dim.clone());
                    sixel_cache.write().unwrap().insert(dim, res);
                    *state.write().unwrap() = ContentState::Ok(content);
                });

                (None, ContentState::Running)
            },
            ContentState::Running => (None, ContentState::Running),
        };

        let _ = std::mem::replace(&mut *state.write().unwrap(), state_cont);

        res
    }
}

pub struct Content {