Struct semilattice_database::Session

pub struct Session { /* private fields */ }

Implementations

impl Session

pub fn new(
    main_database: &Database,
    name: impl Into<String>
) -> Result<Self, Error>

Examples found in repository

src/lib.rs (line 92)

    pub fn session(&self, session_name: &str) -> Result<Session, std::io::Error> {
        let session_dir = self.session_dir(session_name);
        if !std::path::Path::new(&session_dir).exists() {
            std::fs::create_dir_all(&session_dir)?;
        }
        Session::new(self, session_name)
    }

pub fn name(&mut self) -> &str

Examples found in repository

src/lib.rs (line 102)

    pub fn session_clear(&self, session: &mut Session) -> Result<(), std::io::Error> {
        let session_dir = self.session_dir(session.name());
        session.session_data = None;
        if std::path::Path::new(&session_dir).exists() {
            std::fs::remove_dir_all(&session_dir)?;
        }
        Ok(())
    }
    pub fn session_start(&self, session: &mut Session) {
        let session_dir = self.session_dir(session.name());
        if let Ok(session_data) = Session::new_data(&session_dir) {
            session.session_data = Some(session_data);
        }
    }
    pub fn session_restart(&self, session: &mut Session) -> Result<(), std::io::Error> {
        self.session_clear(session)?;
        self.session_start(session);
        Ok(())
    }
    pub fn update(
        &self,
        session: &mut Session,
        records: Vec<Record>,
    ) -> Result<(), std::io::Error> {
        let session_dir = self.session_dir(session.name());
        if let None = session.session_data {
            if let Ok(session_data) = Session::new_data(&session_dir) {
                session.session_data = Some(session_data);
            }
        }
        if let Some(ref mut session_data) = session.session_data {
            let sequence = session_data.sequence_number.next();
            update::update_recursive(
                self,
                session_data,
                &mut session.temporary_data,
                &session_dir,
                sequence,
                &records,
                None,
            )?;
        }
        Ok(())
    }

pub fn new_data(session_dir: &str) -> Result<SessionData, Error>

Examples found in repository

src/lib.rs (line 111)

    pub fn session_start(&self, session: &mut Session) {
        let session_dir = self.session_dir(session.name());
        if let Ok(session_data) = Session::new_data(&session_dir) {
            session.session_data = Some(session_data);
        }
    }
    pub fn session_restart(&self, session: &mut Session) -> Result<(), std::io::Error> {
        self.session_clear(session)?;
        self.session_start(session);
        Ok(())
    }
    pub fn update(
        &self,
        session: &mut Session,
        records: Vec<Record>,
    ) -> Result<(), std::io::Error> {
        let session_dir = self.session_dir(session.name());
        if let None = session.session_data {
            if let Ok(session_data) = Session::new_data(&session_dir) {
                session.session_data = Some(session_data);
            }
        }
        if let Some(ref mut session_data) = session.session_data {
            let sequence = session_data.sequence_number.next();
            update::update_recursive(
                self,
                session_data,
                &mut session.temporary_data,
                &session_dir,
                sequence,
                &records,
                None,
            )?;
        }
        Ok(())
    }

src/session.rs (line 97)

    pub fn new(main_database: &Database, name: impl Into<String>) -> Result<Self, std::io::Error> {
        let mut name: String = name.into();
        assert!(name != "");
        if name == "" {
            name = "untitiled".to_owned();
        }
        let session_dir = main_database.root_dir().to_string() + "/sessions/" + &name;
        if !std::path::Path::new(&session_dir).exists() {
            std::fs::create_dir_all(&session_dir).unwrap();
        }
        let session_data = Self::new_data(&session_dir)?;
        let temporary_data = Self::init_temporary_data(&session_data);
        Ok(Self {
            name,
            session_data: Some(session_data),
            temporary_data,
        })
    }

pub fn begin_search(&self, collection_id: i32) -> SessionSearch<'_>

pub fn search(
    &self,
    collection_id: i32,
    condtions: &Vec<Condition>
) -> SessionSearch<'_>

pub fn field_bytes<'a>(
    &'a self,
    database: &'a Database,
    collection_id: i32,
    row: i64,
    key: &str
) -> &[u8]

pub fn collection_field_bytes<'a>(
    &'a self,
    collection: &'a Collection,
    row: i64,
    key: &str
) -> &[u8]

pub fn temporary_collection(
    &self,
    collection_id: i32
) -> Option<&HashMap<i64, TemporaryDataEntity>>

pub fn depends(
    &self,
    key: Option<&str>,
    pend_row: u32
) -> Option<Vec<SessionDepend>>

Examples found in repository

src/lib.rs (line 235)

    pub fn depends(
        &self,
        key: Option<&str>,
        pend_collection_id: i32,
        pend_row: i64,
        session: Option<&Session>,
    ) -> Vec<SessionDepend> {
        let mut r: Vec<SessionDepend> = vec![];
        if pend_row > 0 {
            let depends = self.relation.depends(
                key,
                &CollectionRow::new(pend_collection_id, pend_row as u32),
            );
            for i in depends {
                r.push(i.into());
            }
        } else {
            if let Some(session) = session {
                if let Some(session_depends) = session.depends(key, (-pend_row) as u32) {
                    r = session_depends;
                }
            }
        }
        r
    }