Enum GraphStorage 

pub enum GraphStorage {
    Mem(LockedGraph),
    Unlocked(Arc<TemporalGraph>),
}

Variants

Mem(LockedGraph)

Unlocked(Arc<TemporalGraph>)

Implementations

impl GraphStorage

pub fn ptr_eq(&self, other: &Self) -> bool

Check if two storage instances point at the same underlying storage

pub fn mutable(&self) -> Result<&Arc<TemporalGraph>, MutationError>

pub fn is_immutable(&self) -> bool

pub fn lock(&self) -> Self

pub fn nodes(&self) -> NodesStorageEntry<'_>

pub fn internalise_node(&self, v: NodeRef<'_>) -> Option<VID>

pub fn unfiltered_num_nodes(&self) -> usize

pub fn unfiltered_num_edges(&self) -> usize

pub fn unfiltered_num_layers(&self) -> usize

pub fn core_nodes(&self) -> NodesStorage

pub fn core_node<'a>(&'a self, vid: VID) -> NodeStorageEntry<'a>

pub fn try_core_node<'a>(&'a self, vid: VID) -> Option<NodeStorageEntry<'a>>

Try to get a node that may not be initialised yet

pub fn edges(&self) -> EdgesStorageRef<'_>

pub fn owned_edges(&self) -> EdgesStorage

pub fn edge_entry(&self, eid: EID) -> EdgeStorageEntry<'_>

pub fn layer_ids_iter( &self, layer_ids: &LayerIds, ) -> impl Iterator<Item = usize>

pub fn node_meta(&self) -> &Meta

pub fn edge_meta(&self) -> &Meta

pub fn graph_meta(&self) -> &GraphMeta

Trait Implementations

impl Clone for GraphStorage

fn clone(&self) -> GraphStorage

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CoreGraphOps for GraphStorage

fn core_graph(&self) -> &GraphStorage

fn id_type(&self) -> Option<GidType>

fn num_shards(&self) -> usize

fn read_event_id(&self) -> usize

get the current sequence id without incrementing the counter

fn unfiltered_num_nodes(&self) -> usize

get the number of nodes in the main graph

fn unfiltered_num_edges(&self) -> usize

get the number of edges in the main graph

fn unfiltered_num_layers(&self) -> usize

get the number of layers in the main graph

fn single_layer(&self, layer_ids: &LayerIds) -> Option<usize>

Return the id of the single layer if layer_ids reduces to a graph with a single layer, else None

fn core_edges(&self) -> EdgesStorage

fn core_edge(&self, eid: EID) -> EdgeStorageEntry<'_>

fn core_nodes(&self) -> NodesStorage

fn core_node(&self, vid: VID) -> NodeStorageEntry<'_>

fn node_meta(&self) -> &Meta

fn edge_meta(&self) -> &Meta

fn graph_meta(&self) -> &GraphMeta

fn get_layer_name(&self, layer_id: usize) -> ArcStr

fn get_layer_id(&self, name: &str) -> Option<usize>

fn get_default_layer_id(&self) -> Option<usize>

fn get_layer_names_from_ids(&self, layer_ids: &LayerIds) -> BoxedIter<ArcStr>

Get the layer name for a given id

fn get_all_node_types(&self) -> Vec<ArcStr>

Get all node types

fn node_id(&self, v: VID) -> GID

Returns the external ID for a node

fn node_name(&self, v: VID) -> String

Returns the string name for a node

fn node_type(&self, v: VID) -> Option<ArcStr>

Returns the type of node

fn node_type_id(&self, v: VID) -> usize

Returns the type id of a node

fn internalise_node(&self, v: NodeRef<'_>) -> Option<VID>

Gets the internal reference for an external node reference and keeps internal references unchanged.

fn internalise_node_unchecked(&self, v: NodeRef<'_>) -> VID

Gets the internal reference for an external node reference and keeps internal references unchanged. Assumes node exists!

fn node_metadata(&self, v: VID, id: usize) -> Option<Prop>

Gets a static property of a given node given the name and node reference.

fn node_metadata_ids(&self, v: VID) -> BoxedLIter<'_, usize>

Gets the keys of metadata of a given node

fn temporal_node_prop_ids(&self, v: VID) -> Box<dyn Iterator<Item = usize> + '_>

Returns a vector of all ids of temporal properties within the given node

impl Debug for GraphStorage

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

Formats the value using the given formatter.

impl Default for GraphStorage

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for GraphStorage

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for GraphStorage

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

Formats the value using the given formatter.

impl From<TemporalGraph> for GraphStorage

fn from(value: TemporalGraph) -> Self

Converts to this type from the input type.

impl InternalAdditionOps for GraphStorage

type Error = MutationError

fn write_lock(&self) -> Result<WriteLockedGraph<'_>, Self::Error>

fn write_lock_nodes(&self) -> Result<WriteLockedNodes<'_>, Self::Error>

fn write_lock_edges(&self) -> Result<WriteLockedEdges<'_>, Self::Error>

fn next_event_id(&self) -> Result<usize, Self::Error>

get the sequence id for the next event

fn reserve_event_ids(&self, num_ids: usize) -> Result<usize, Self::Error>

fn resolve_layer( &self, layer: Option<&str>, ) -> Result<MaybeNew<usize>, Self::Error>

map layer name to id and allocate a new layer if needed

fn resolve_node(&self, id: NodeRef<'_>) -> Result<MaybeNew<VID>, Self::Error>

map external node id to internal id, allocating a new empty node if needed

fn set_node(&self, gid: GidRef<'_>, vid: VID) -> Result<(), Self::Error>

fn resolve_node_and_type( &self, id: NodeRef<'_>, node_type: &str, ) -> Result<MaybeNew<(MaybeNew<VID>, MaybeNew<usize>)>, Self::Error>

resolve a node and corresponding type, outer MaybeNew tracks whether the type assignment is new for the node even if both node and type already existed.

fn resolve_graph_property( &self, prop: &str, dtype: PropType, is_static: bool, ) -> Result<MaybeNew<usize>, Self::Error>

map property key to internal id, allocating new property if needed

fn resolve_node_property( &self, prop: &str, dtype: PropType, is_static: bool, ) -> Result<MaybeNew<usize>, Self::Error>

map property key to internal id, allocating new property if needed and checking property type. returns None if the type does not match

fn resolve_edge_property( &self, prop: &str, dtype: PropType, is_static: bool, ) -> Result<MaybeNew<usize>, Self::Error>

fn internal_add_node( &self, t: TimeIndexEntry, v: VID, props: &[(usize, Prop)], ) -> Result<(), Self::Error>

add node update

fn internal_add_edge( &self, t: TimeIndexEntry, src: VID, dst: VID, props: &[(usize, Prop)], layer: usize, ) -> Result<MaybeNew<EID>, Self::Error>

add edge update

fn internal_add_edge_update( &self, t: TimeIndexEntry, edge: EID, props: &[(usize, Prop)], layer: usize, ) -> Result<(), Self::Error>

add update for an existing edge

impl InternalDeletionOps for GraphStorage

type Error = MutationError

fn internal_delete_edge( &self, t: TimeIndexEntry, src: VID, dst: VID, layer: usize, ) -> Result<MaybeNew<EID>, Self::Error>

fn internal_delete_existing_edge( &self, t: TimeIndexEntry, eid: EID, layer: usize, ) -> Result<(), Self::Error>

impl InternalLayerOps for GraphStorage

fn layer_ids(&self) -> &LayerIds

get the layer ids for the graph view

fn layer_ids_from_names(&self, key: Layer) -> Result<LayerIds, InvalidLayer>

Get the layer id for the given layer name

fn valid_layer_ids_from_names(&self, key: Layer) -> LayerIds

Get the valid layer ids for given layer names

impl InternalPropertyAdditionOps for GraphStorage

type Error = MutationError

fn internal_add_properties( &self, t: TimeIndexEntry, props: &[(usize, Prop)], ) -> Result<(), Self::Error>

fn internal_add_metadata( &self, props: &[(usize, Prop)], ) -> Result<(), Self::Error>

fn internal_update_metadata( &self, props: &[(usize, Prop)], ) -> Result<(), Self::Error>

fn internal_add_node_metadata( &self, vid: VID, props: &[(usize, Prop)], ) -> Result<EntryMut<'_, RwLockWriteGuard<'_, NodeSlot>>, Self::Error>

fn internal_update_node_metadata( &self, vid: VID, props: &[(usize, Prop)], ) -> Result<EntryMut<'_, RwLockWriteGuard<'_, NodeSlot>>, Self::Error>

fn internal_add_edge_metadata( &self, eid: EID, layer: usize, props: &[(usize, Prop)], ) -> Result<EdgeWGuard<'_>, Self::Error>

fn internal_update_edge_metadata( &self, eid: EID, layer: usize, props: &[(usize, Prop)], ) -> Result<EdgeWGuard<'_>, Self::Error>

impl Serialize for GraphStorage

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

where __S: Serializer,

Serialize this value into the given Serde serializer.