Struct Urn 

pub struct Urn {
    domain: UrnComponent,
    namespace: UrnComponent,
    memory_id: Option<String>,
    original: String,
}

A parsed Subcog URN.

URNs can represent either a specific memory or a filter pattern.

Fields

domain: UrnComponent

Domain component (project, user, org, or wildcard).

namespace: UrnComponent

Namespace component (decisions, learnings, etc., or wildcard).

memory_id: Option<String>

Optional memory ID for specific lookups.

original: String

Original URN string for display.

Implementations

impl Urn

pub fn parse(s: &str) -> Result<Self>

Parses a URN string.

Errors

Returns an error if the string is not a valid Subcog URN.

Examples

use subcog::models::Urn;

// Full URN with memory ID
let urn = Urn::parse("subcog://project/patterns/abc123")?;

// Namespace filter
let urn = Urn::parse("subcog://_/learnings")?;

// Domain filter
let urn = Urn::parse("subcog://user/_")?;

fn parse_component(s: &str) -> UrnComponent

Parses a component, treating _ or empty as wildcard.

pub fn try_parse(s: &str) -> Option<Self>

Tries to parse a string as a URN, returning None if it’s not a URN.

This is useful for checking if a memory_id argument is a URN or a raw ID.

pub fn extract_memory_id(s: &str) -> &str

Extracts just the memory ID from a string that might be a URN.

If the string is a URN, returns the memory_id component (last path segment). If the string is not a URN, returns it as-is (it’s already a raw ID).

pub fn extract_memory_id_owned(s: &str) -> Option<String>

Extracts just the memory ID from a string, returning owned String.

If the string is a URN with a memory_id, returns that ID. If the string is a URN without a memory_id (filter), returns None. If the string is not a URN, returns it as-is (it’s already a raw ID).

pub const fn is_specific(&self) -> bool

Returns true if this URN represents a specific memory (has a memory_id).

pub const fn is_filter(&self) -> bool

Returns true if this URN is a filter pattern (no memory_id, or has wildcards).

pub const fn domain(&self) -> &UrnComponent

Returns the domain component.

pub fn domain_str(&self) -> Option<&str>

Returns the domain as a string, if not a wildcard.

pub const fn namespace(&self) -> &UrnComponent

Returns the namespace component.

pub fn namespace_str(&self) -> Option<&str>

Returns the namespace as a string, if not a wildcard.

pub fn memory_id(&self) -> Option<&str>

Returns the memory ID, if this URN specifies one.

pub fn to_domain(&self) -> Result<Option<Domain>>

Converts the domain component to a Domain, if not a wildcard.

Errors

Returns an error if the domain string is invalid.

pub fn to_namespace(&self) -> Option<Namespace>

Converts the namespace component to a Namespace, if not a wildcard.

pub fn as_str(&self) -> &str

Returns the original URN string.

Trait Implementations

impl Clone for Urn

fn clone(&self) -> Urn

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Urn

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

Formats the value using the given formatter.

impl Display for Urn

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

Formats the value using the given formatter.

impl FromStr for Urn

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self>

Parses a string s to return a value of this type.

impl PartialEq for Urn

fn eq(&self, other: &Urn) -> 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 Eq for Urn

impl StructuralPartialEq for Urn