Struct GraphTypeDef 

pub struct GraphTypeDef {
    pub name: DbString,
    pub node_types: Vec<NodeTypeDef>,
    pub edge_types: Vec<EdgeTypeDef>,
}

Definition of a closed graph type per ISO clause 18.

Fields

name: DbString

Graph type name.

node_types: Vec<NodeTypeDef>

Node-type elements in graph-type order.

edge_types: Vec<EdgeTypeDef>

Edge-type elements in graph-type order.

Implementations

impl GraphTypeDef

pub fn validate(self) -> GraphResult<Self>

Validate this graph type’s structural invariants.

Errors

Returns GraphError::Inconsistent when the type contains duplicate names, invalid edge endpoint indexes, duplicate properties within a node/edge type, duplicate edge triples, or an empty node label set.

pub fn find_node_type(&self, labels: &LabelSet) -> Option<&NodeTypeDef>

Return the first node type matching labels.

pub fn find_node_type_index(&self, labels: &LabelSet) -> Option<u32>

Return the first node-type index matching labels.

pub fn node_type_index_for(&self, name: DbString) -> Option<u32>

Return the node-type index matching name.

pub fn find_edge_type( &self, label: DbString, source_node_type: u32, target_node_type: u32, ) -> Option<&EdgeTypeDef>

Return the edge type matching label and observed endpoint node types.

pub fn first_edge_type_with_label( &self, label: DbString, ) -> Option<&EdgeTypeDef>

Return the first edge type carrying label.

pub fn edge_type_index_for(&self, name: DbString) -> Option<u32>

Return the edge-type index matching name.

pub fn without_node_type(&self, name: DbString) -> Option<Self>

Return a copy with the named node type removed.

Edge endpoint indexes are intentionally not rewritten. Callers that cannot tolerate positional drift must reject the drop before using this helper.

pub fn without_edge_type(&self, name: DbString) -> Option<Self>

Return a copy with the named edge type removed.

pub fn validate_ref(&self) -> GraphResult<()>

Validate the type without consuming it.

Same checks as GraphTypeDef::validate; preferred when callers already hold a reference (recovery, crate::SharedGraph::from_graph re-validation) and cannot move the value.

Trait Implementations

impl Archive for GraphTypeDef

where DbString: Archive, Vec<NodeTypeDef>: Archive, Vec<EdgeTypeDef>: Archive,

const COPY_OPTIMIZATION: CopyOptimization<Self>

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

type Archived = ArchivedGraphTypeDef

The archived representation of this type.

type Resolver = GraphTypeDefResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

impl Clone for GraphTypeDef

fn clone(&self) -> GraphTypeDef

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for GraphTypeDef

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for GraphTypeDef

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<__D: Fallible + ?Sized> Deserialize<GraphTypeDef, __D> for Archived<GraphTypeDef>

where DbString: Archive, <DbString as Archive>::Archived: Deserialize<DbString, __D>, Vec<NodeTypeDef>: Archive, <Vec<NodeTypeDef> as Archive>::Archived: Deserialize<Vec<NodeTypeDef>, __D>, Vec<EdgeTypeDef>: Archive, <Vec<EdgeTypeDef> as Archive>::Archived: Deserialize<Vec<EdgeTypeDef>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<GraphTypeDef, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl PartialEq for GraphTypeDef

fn eq(&self, other: &GraphTypeDef) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for GraphTypeDef

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<__S: Fallible + ?Sized> Serialize<__S> for GraphTypeDef

where DbString: Serialize<__S>, Vec<NodeTypeDef>: Serialize<__S>, Vec<EdgeTypeDef>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl StructuralPartialEq for GraphTypeDef