Method create_view

atomic-core/src/pristine/txn/write/mod.rs:918–984

(
        &mut self,
        name: &str,
        kind: ViewScope,
        parent: Option<u64>,
    )

    }

    fn create_view(
        &mut self,
        name: &str,
        kind: ViewScope,
        parent: Option<u64>,
    ) -> PristineResult<ViewState> {
        // Check if view already exists
        {
            let table = self.txn.open_table(VIEWS)?;
            if table.get(name)?.is_some() {
                return Err(PristineError::ViewAlreadyExists {
                    name: name.to_string(),
                });
            }
        }

        // Validate parent exists if specified, and detect cycles
        if let Some(parent_id) = parent {
            let parent_view = ViewTxnT::get_view_by_id(self, parent_id)?.ok_or_else(|| {
                PristineError::ViewNotFound {
                    name: format!("parent view id={}", parent_id),
                }
            })?;

            // Cycle detection: walk the parent chain from the proposed parent
            // upward. If we ever encounter our own (not-yet-allocated) name,
            // there's a cycle. Since the view doesn't exist yet, we only need
            // to check that the parent chain terminates without revisiting
            // `parent_id` — which is guaranteed as long as the existing graph
            // is acyclic and we're adding a leaf.
            //
            // However, we also guard against the degenerate case where someone
            // passes parent == self (once IDs are known). Since we haven't
            // allocated an ID yet, the only risk is the parent chain itself
            // being cyclic (which would be a pre-existing bug). We do a bounded
            // walk as a safety check.
            let mut visited = std::collections::HashSet::new();
            visited.insert(parent_id);
            let mut cursor = parent_view.parent;
            while let Some(ancestor_id) = cursor {
                if !visited.insert(ancestor_id) {
                    // We've seen this ID before — cycle detected in existing chain
                    return Err(PristineError::ViewCycleDetected {
                        name: name.to_string(),
                        parent_name: parent_view.name.clone(),
                    });
                }
                match ViewTxnT::get_view_by_id(self, ancestor_id)? {
                    Some(ancestor) => cursor = ancestor.parent,
                    None => break, // Broken chain — parent doesn't exist (shouldn't happen)
                }
            }
        }

        // Allocate ID and create state
        let id = self.next_view_id.fetch_add(1, Ordering::SeqCst);
        let state = ViewState::with_scope(id, name.to_string(), kind, parent);