Struct retworkx::PyDAG

pub struct PyDAG { /* fields omitted */ }

Methods

impl PyDAG

pub fn edges(&self, py: Python) -> PyObject

pub fn nodes(&self, py: Python) -> PyObject

pub fn node_indexes(&self, py: Python) -> PyObject

pub fn has_edge(&self, node_a: usize, node_b: usize) -> bool

pub fn successors(&self, py: Python, node: usize) -> PyResult<PyObject>

pub fn predecessors(&self, py: Python, node: usize) -> PyResult<PyObject>

pub fn get_edge_data(&self, node_a: usize, node_b: usize) -> PyResult<&PyObject>

pub fn get_node_data(&self, node: usize) -> PyResult<&PyObject>

pub fn get_all_edge_data(
    &self,
    py: Python,
    node_a: usize,
    node_b: usize
) -> PyResult<PyObject>

pub fn remove_node(&mut self, node: usize) -> PyResult<()>

pub fn add_edge(
    &mut self,
    parent: usize,
    child: usize,
    edge: PyObject
) -> PyResult<usize>

pub fn remove_edge(&mut self, parent: usize, child: usize) -> PyResult<()>

pub fn remove_edge_from_index(&mut self, edge: usize) -> PyResult<()>

pub fn add_node(&mut self, obj: PyObject) -> PyResult<usize>

pub fn add_child(
    &mut self,
    parent: usize,
    obj: PyObject,
    edge: PyObject
) -> PyResult<usize>

pub fn add_parent(
    &mut self,
    child: usize,
    obj: PyObject,
    edge: PyObject
) -> PyResult<usize>

pub fn adj(&mut self, py: Python, node: usize) -> PyResult<PyObject>

pub fn adj_direction(
    &mut self,
    py: Python,
    node: usize,
    direction: bool
) -> PyResult<PyObject>

pub fn in_edges(&mut self, py: Python, node: usize) -> PyResult<PyObject>

pub fn out_edges(&mut self, py: Python, node: usize) -> PyResult<PyObject>

pub fn in_degree(&self, node: usize) -> usize

pub fn out_degree(&self, node: usize) -> usize

Trait Implementations

impl Data for PyDAG

type NodeWeight = PyObject

type EdgeWeight = PyObject

impl DataMap for PyDAG

fn node_weight(&self, id: Self::NodeId) -> Option<&Self::NodeWeight>

fn edge_weight(&self, id: Self::EdgeId) -> Option<&Self::EdgeWeight>

impl DataMapMut for PyDAG

fn node_weight_mut(&mut self, id: Self::NodeId) -> Option<&mut Self::NodeWeight>

fn edge_weight_mut(&mut self, id: Self::EdgeId) -> Option<&mut Self::EdgeWeight>

impl GetAdjacencyMatrix for PyDAG

type AdjMatrix = <StableDiGraph<PyObject, PyObject> as GetAdjacencyMatrix>::AdjMatrix

The associated adjacency matrix type

fn adjacency_matrix(&self) -> Self::AdjMatrix

Create the adjacency matrix

fn is_adjacent(
    &self,
    matrix: &Self::AdjMatrix,
    a: NodeIndex,
    b: NodeIndex
) -> bool

Return true if there is an edge from a to b, false otherwise.

impl GraphBase for PyDAG

type NodeId = NodeIndex

node identifier

type EdgeId = EdgeIndex

edge identifier

impl GraphProp for PyDAG

type EdgeType = Directed

The kind edges in the graph.

fn is_directed(&self) -> bool

impl Index<EdgeIndex<u32>> for PyDAG

type Output = PyObject

The returned type after indexing.

fn index(&self, index: EdgeIndex) -> &PyObject

Performs the indexing (container[index]) operation.

impl Index<NodeIndex<u32>> for PyDAG

type Output = PyObject

The returned type after indexing.

fn index(&self, index: NodeIndex) -> &PyObject

Performs the indexing (container[index]) operation.

impl IndexMut<EdgeIndex<u32>> for PyDAG

fn index_mut(&mut self, index: EdgeIndex) -> &mut PyObject

Performs the mutable indexing (container[index]) operation.

impl IndexMut<NodeIndex<u32>> for PyDAG

fn index_mut(&mut self, index: NodeIndex) -> &mut PyObject

Performs the mutable indexing (container[index]) operation.

impl<'a> IntoEdgeReferences for &'a PyDAG

type EdgeRef = EdgeReference<'a, PyObject>

type EdgeReferences = EdgeReferences<'a, PyObject>

fn edge_references(self) -> Self::EdgeReferences

impl<'a> IntoEdges for &'a PyDAG

type Edges = Edges<'a, PyObject>

fn edges(self, a: Self::NodeId) -> Self::Edges

impl<'a> IntoEdgesDirected for &'a PyDAG

type EdgesDirected = Edges<'a, PyObject>

fn edges_directed(self, a: Self::NodeId, dir: Direction) -> Self::EdgesDirected

impl<'a> IntoNeighbors for &'a PyDAG

type Neighbors = Neighbors<'a, PyObject>

fn neighbors(self, n: NodeIndex) -> Self::Neighbors

Return an iterator of the neighbors of node a.

impl<'a> IntoNeighborsDirected for &'a PyDAG

type NeighborsDirected = Neighbors<'a, PyObject>

fn neighbors_directed(self, n: NodeIndex, d: Direction) -> Self::Neighbors

impl<'a> IntoNodeIdentifiers for &'a PyDAG

type NodeIdentifiers = NodeIndices<'a, PyObject>

fn node_identifiers(self) -> Self::NodeIdentifiers

impl<'a> IntoNodeReferences for &'a PyDAG

type NodeRef = (NodeIndex, &'a PyObject)

type NodeReferences = NodeReferences<'a, PyObject>

fn node_references(self) -> Self::NodeReferences

impl IntoPy<PyObject> for PyDAG

fn into_py(self, py: Python) -> PyObject

Performs the conversion.

impl NodeCompactIndexable for PyDAG

impl NodeCount for PyDAG

fn node_count(&self) -> usize

impl NodeIndexable for PyDAG

fn node_bound(&self) -> usize

Return an upper bound of the node indices in the graph (suitable for the size of a bitmap).

fn to_index(&self, ix: NodeIndex) -> usize

Convert a to an integer index.

fn from_index(&self, ix: usize) -> Self::NodeId

Convert i to a node index

impl<'p> PyMappingLenProtocol<'p> for PyDAG

type Result = PyResult<usize>

impl<'p> PyMappingProtocol<'p> for PyDAG

fn __len__(&'p self) -> <PyDAG as PyMappingLenProtocol<'p>>::Result

fn __getitem__(&'p self, key: Self::Key) -> Self::Result where
    Self: PyMappingGetItemProtocol<'p>, 

fn __setitem__(&'p mut self, key: Self::Key, value: Self::Value) -> Self::Result where
    Self: PyMappingSetItemProtocol<'p>, 

fn __delitem__(&'p mut self, key: Self::Key) -> Self::Result where
    Self: PyMappingDelItemProtocol<'p>, 

fn __reversed__(&'p self) -> Self::Result where
    Self: PyMappingReversedProtocol<'p>, 

impl PyMethodsInventoryDispatch for PyDAG

type InventoryType = PyDAGGeneratedPyo3Inventory

This allows us to get the inventory type when only the pyclass is in scope

impl PyObjectAlloc for PyDAG

unsafe fn alloc(_py: Python) -> *mut PyObject

unsafe fn dealloc(py: Python, obj: *mut PyObject)

Calls the rust destructor for the object and frees the memory (usually by calling ptr->ob_type->tp_free). This function is used as tp_dealloc implementation.

unsafe fn drop(py: Python, obj: *mut PyObject)

Calls the rust destructor for the object.

impl PyTypeInfo for PyDAG

type Type = PyDAG

Type of objects to store in PyObject struct

type BaseType = PyAny

Base class

const NAME: &'static str

Class name

const MODULE: Option<&'static str>

Module name, if any

const DESCRIPTION: &'static str

Class doc string

const FLAGS: usize

Type flags (ie PY_TYPE_FLAG_GC, PY_TYPE_FLAG_WEAKREF)

const SIZE: usize

Size of the rust PyObject structure (PyObject + rust structure)

const OFFSET: isize

Type instance offset inside PyObject structure

unsafe fn type_object() -> &'static mut PyTypeObject

PyTypeObject instance for this type, which might still need to be initialized

fn is_instance(object: &PyAny) -> bool

Check if *mut ffi::PyObject is instance of this type

fn is_exact_instance(object: &PyAny) -> bool

Check if *mut ffi::PyObject is exact instance of this type

impl Visitable for PyDAG

type Map = <StableDiGraph<PyObject, PyObject> as Visitable>::Map

The associated map type

fn visit_map(&self) -> Self::Map

Create a new visitor map

fn reset_map(&self, map: &mut Self::Map)

Reset the visitor map (and resize to new size of graph if needed)