Struct AgentId 

pub struct AgentId(/* private fields */);

Unique identifier for a runtime agent (format: agent_<uuid>)

Implementations

impl AgentId

pub fn parse(s: impl AsRef<str>) -> Result<Self, IdError>

Parse an ID from a string, validating format

Security

Failed parse attempts are logged when the telemetry feature is enabled. This provides security monitoring for potential attack attempts.

pub fn parse_flexible(s: impl AsRef<str>) -> Result<Self, IdError>

Parse an ID accepting both current (underscore) and legacy (hyphen) formats

This method provides backward compatibility during migration periods when both ID formats may exist in the system (e.g., database, logs, external APIs).

Format Support

• Current format (underscore): prefix_uuid (e.g., agent_abc123)
• Legacy format (hyphen): prefix-uuid (e.g., agent-abc123)

The legacy format is automatically normalized to the current underscore format.

Security

Failed parse attempts are logged when the telemetry feature is enabled, regardless of which format was attempted.

Production Migration

Use this method when:

• Reading IDs from databases that contain legacy format
• Deserializing IDs from old API responses or config files
• Processing IDs from external systems during migration

Once migration is complete, prefer parse() for strict validation.

Example

use iron_types::AgentId;

// Current format
let id1 = AgentId::parse_flexible("agent_550e8400-e29b-41d4-a716-446655440000").unwrap();

// Legacy format (auto-normalized)
let id2 = AgentId::parse_flexible("agent-550e8400-e29b-41d4-a716-446655440000").unwrap();

// Both produce same normalized ID
assert_eq!(id1.as_str(), "agent_550e8400-e29b-41d4-a716-446655440000");
assert_eq!(id2.as_str(), "agent_550e8400-e29b-41d4-a716-446655440000");

pub fn generate() -> Self

Generate a new random ID

pub fn as_str(&self) -> &str

Get the ID as a string slice

pub fn prefix() -> &'static str

Get the prefix for this ID type

Trait Implementations

impl AsRef<str> for AgentId

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for AgentId

fn clone(&self) -> AgentId

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AgentId

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AgentId

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for AgentId

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

Formats the value using the given formatter.

impl From<AgentId> for String

fn from(id: AgentId) -> Self

Converts to this type from the input type.

impl FromStr for AgentId

type Err = IdError

The associated error which can be returned from parsing.

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

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

impl Hash for AgentId

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

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 for AgentId

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<String> for AgentId

type Error = IdError

The type returned in the event of a conversion error.

fn try_from(value: String) -> Result<Self, Self::Error>

Performs the conversion.

impl Eq for AgentId

impl StructuralPartialEq for AgentId