Struct semilattice_database::SessionDepend

source ·

pub struct SessionDepend { /* private fields */ }

Implementations§

source §

impl SessionDepend

source

pub fn new(key: &str, collection_row: SessionCollectionRow) -> Self

Examples found in repository ?

src/relation.rs (lines 104-110)

    pub fn depends(&self, key: Option<&str>, pend: &CollectionRow) -> Vec<SessionDepend> {
        let mut ret: Vec<SessionDepend> = Vec::new();
        if let Some(key_name) = key {
            if let Some(key) = self.key_names.find_row(key_name.as_bytes()) {
                let c = self.rows.pend.select_by_value(pend);
                for i in c {
                    if let (Some(key_row), Some(collection_row)) =
                        (self.rows.key.value(i), self.rows.pend.value(i))
                    {
                        if key_row == key {
                            ret.push(SessionDepend::new(
                                key_name,
                                SessionCollectionRow::new(
                                    collection_row.collection_id(),
                                    collection_row.row() as i64,
                                ),
                            ));
                        }
                    }
                }
            }
        } else {
            let c = self.rows.pend.select_by_value(pend);
            for i in c {
                if let (Some(key), Some(collection_row)) =
                    (self.rows.key.value(i), self.rows.pend.value(i))
                {
                    ret.push(SessionDepend::new(
                        unsafe { self.key_names.str(key) },
                        SessionCollectionRow::new(
                            collection_row.collection_id(),
                            collection_row.row() as i64,
                        ),
                    ));
                }
            }
        }
        ret
    }

More examples

Hide additional examples

src/session.rs (line 263)

    pub fn depends(&self, key: Option<&str>, pend_row: u32) -> Option<Vec<SessionDepend>> {
        let mut r = vec![];
        if let Some(ref session_data) = self.session_data {
            if let Some(key_name) = key {
                if let Some(key_id) = session_data
                    .relation
                    .key_names
                    .find_row(key_name.as_bytes())
                {
                    for relation_row in session_data
                        .relation
                        .rows
                        .session_row
                        .select_by_value(&pend_row)
                        .iter()
                    {
                        if let (Some(key), Some(depend)) = (
                            session_data.relation.rows.key.value(*relation_row),
                            session_data.relation.rows.depend.value(*relation_row),
                        ) {
                            if key == key_id {
                                r.push(SessionDepend::new(key_name, depend));
                            }
                        }
                    }
                    return Some(r);
                }
            } else {
                for relation_row in session_data
                    .relation
                    .rows
                    .session_row
                    .select_by_value(&pend_row)
                    .iter()
                {
                    if let (Some(key), Some(depend)) = (
                        session_data.relation.rows.key.value(*relation_row),
                        session_data.relation.rows.depend.value(*relation_row),
                    ) {
                        r.push(SessionDepend::new(
                            unsafe { session_data.relation.key_names.str(key) },
                            depend,
                        ));
                    }
                }
                return Some(r);
            }
        }
        None
    }