Struct BlankNodeRef 

pub struct BlankNodeRef<'a>(/* private fields */);

A borrowed RDF blank node.

The common way to create a new blank node is to use the BlankNode::default trait method.

It is also possible to create a blank node from a blank node identifier using the BlankNodeRef::new() function. The blank node identifier must be valid according to N-Triples, Turtle, and SPARQL grammars.

The default string formatter is returning an N-Triples, Turtle, and SPARQL compatible representation:

use oxrdf::BlankNodeRef;

assert_eq!("_:a122", BlankNodeRef::new("a122")?.to_string());

Implementations

impl<'a> BlankNodeRef<'a>

pub fn new(id: &'a str) -> Result<BlankNodeRef<'a>, BlankNodeIdParseError>

Creates a blank node from a unique identifier.

The blank node identifier must be valid according to N-Triples, Turtle, and SPARQL grammars.

In most cases, it is much more convenient to create a blank node using BlankNode::default(). that creates a random ID that could be easily inlined by Oxigraph stores.

pub fn new_unchecked(id: &'a str) -> BlankNodeRef<'a>

Creates a blank node from a unique identifier without validation.

It is the caller’s responsibility to ensure that id is a valid blank node identifier according to N-Triples, Turtle, and SPARQL grammars.

[BlankNodeRef::new()) is a safe version of this constructor and should be used for untrusted data.

pub const fn as_str(self) -> &'a str

Returns the underlying ID of this blank node.

pub const fn unique_id(&self) -> Option<u128>

Returns the internal numerical ID of this blank node if it has been created using BlankNode::new_from_unique_id.

use oxrdf::BlankNode;

assert_eq!(
    BlankNode::new_from_unique_id(128).as_ref().unique_id(),
    Some(128)
);
assert_eq!(BlankNode::new("foo")?.as_ref().unique_id(), None);

pub fn into_owned(self) -> BlankNode

Trait Implementations

impl<'a> Clone for BlankNodeRef<'a>

fn clone(&self) -> BlankNodeRef<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for BlankNodeRef<'a>

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

Formats the value using the given formatter.

impl Display for BlankNodeRef<'_>

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

Formats the value using the given formatter.

impl<'a> From<&'a BlankNode> for BlankNodeRef<'a>

fn from(node: &'a BlankNode) -> BlankNodeRef<'a>

Converts to this type from the input type.

impl From<BlankNodeRef<'_>> for GraphName

fn from(node: BlankNodeRef<'_>) -> GraphName

Converts to this type from the input type.

impl From<BlankNodeRef<'_>> for NamedOrBlankNode

fn from(node: BlankNodeRef<'_>) -> NamedOrBlankNode

Converts to this type from the input type.

impl From<BlankNodeRef<'_>> for PlainTermScalar

fn from(term: BlankNodeRef<'_>) -> PlainTermScalar

Converts to this type from the input type.

impl From<BlankNodeRef<'_>> for Term

fn from(node: BlankNodeRef<'_>) -> Term

Converts to this type from the input type.

impl<'a> From<BlankNodeRef<'a>> for BlankNode

fn from(node: BlankNodeRef<'a>) -> BlankNode

Converts to this type from the input type.

impl<'a> From<BlankNodeRef<'a>> for GraphNameRef<'a>

fn from(node: BlankNodeRef<'a>) -> GraphNameRef<'a>

Converts to this type from the input type.

impl<'a> From<BlankNodeRef<'a>> for NamedOrBlankNodeRef<'a>

fn from(node: BlankNodeRef<'a>) -> NamedOrBlankNodeRef<'a>

Converts to this type from the input type.

impl<'a> From<BlankNodeRef<'a>> for TermRef<'a>

fn from(node: BlankNodeRef<'a>) -> TermRef<'a>

Converts to this type from the input type.

impl<'a> Hash for BlankNodeRef<'a>

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq<BlankNode> for BlankNodeRef<'_>

fn eq(&self, other: &BlankNode) -> 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 PartialEq<BlankNodeRef<'_>> for BlankNode

fn eq(&self, other: &BlankNodeRef<'_>) -> 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<'a> PartialEq for BlankNodeRef<'a>

fn eq(&self, other: &BlankNodeRef<'a>) -> 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<'a> Copy for BlankNodeRef<'a>

impl<'a> Eq for BlankNodeRef<'a>

impl<'a> StructuralPartialEq for BlankNodeRef<'a>