Struct Name

pub struct Name {
    pub formatted: Option<String>,
    pub family_name: Option<String>,
    pub given_name: Option<String>,
    pub middle_name: Option<String>,
    pub honorific_prefix: Option<String>,
    pub honorific_suffix: Option<String>,
}

A validated SCIM name attribute.

Name represents the components of a user’s real name as defined in RFC 7643. It enforces validation rules at construction time, ensuring that only valid name attributes can exist in the system.

Validation Rules

• At least one name component must be provided (not all fields can be empty/None)
• Individual name components cannot be empty strings
• All fields are optional but if provided must contain meaningful content

Examples

use scim_server::resource::value_objects::Name;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create with full name components
    let name = Name::new(
        Some("Ms. Barbara J Jensen, III".to_string()),
        Some("Jensen".to_string()),
        Some("Barbara".to_string()),
        Some("Jane".to_string()),
        Some("Ms.".to_string()),
        Some("III".to_string())
    )?;

    // Create with minimal components
    let simple_name = Name::new_simple(
        "John".to_string(),
        "Doe".to_string()
    )?;

    Ok(())
}

Fields

formatted: Option<String>

family_name: Option<String>

given_name: Option<String>

middle_name: Option<String>

honorific_prefix: Option<String>

honorific_suffix: Option<String>

Implementations

impl Name

pub fn new( formatted: Option<String>, family_name: Option<String>, given_name: Option<String>, middle_name: Option<String>, honorific_prefix: Option<String>, honorific_suffix: Option<String>, ) -> ValidationResult<Self>

Create a new Name with all components.

This is the primary constructor that enforces all validation rules. Use this method when creating Name instances from untrusted input.

Arguments

• formatted - The full name, formatted for display
• family_name - The family name or last name
• given_name - The given name or first name
• middle_name - The middle name(s)
• honorific_prefix - The honorific prefix or title (e.g., “Ms.”, “Dr.”)
• honorific_suffix - The honorific suffix (e.g., “III”, “Jr.”)

Returns

• Ok(Name) - If at least one field is provided and all provided fields are valid
• Err(ValidationError) - If all fields are None/empty or any field violates validation rules

pub fn new_simple( given_name: String, family_name: String, ) -> ValidationResult<Self>

Create a simple Name with just given and family names.

Convenience constructor for creating basic name structures.

Arguments

• given_name - The given name or first name
• family_name - The family name or last name

Returns

• Ok(Name) - If the names are valid
• Err(ValidationError) - If any name violates validation rules

pub fn new_formatted(formatted: String) -> ValidationResult<Self>

Create a Name with a formatted display name only.

Convenience constructor for cases where only a formatted name is available.

Arguments

• formatted - The full formatted name

Returns

• Ok(Name) - If the formatted name is valid
• Err(ValidationError) - If the name violates validation rules

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

Create a Name instance without validation for internal use. Get the formatted name.

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

Get the family name.

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

Get the given name.

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

Get the middle name.

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

Get the honorific prefix.

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

Get the honorific suffix.

pub fn display_name(&self) -> Option<String>

Generate a formatted display name from components.

Creates a formatted name string from the available name components if no explicit formatted name is provided.

Returns

The formatted name if available, otherwise a constructed name from components, or None if no components are available.

pub fn is_empty(&self) -> bool

Check if the name has any meaningful content.

pub fn from_json(value: &Value) -> ValidationResult<Self>

Create a Name from a JSON value.

Trait Implementations

impl Clone for Name

fn clone(&self) -> Name

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Name

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Name

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Name

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

Formats the value using the given formatter.

impl PartialEq for Name

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

fn from_schema_and_value( definition: &AttributeDefinition, value: &Value, ) -> ValidationResult<Self>

Create a value object from a JSON value and schema definition

fn can_construct_from(definition: &AttributeDefinition) -> bool

Check if this type can handle the given attribute definition

fn constructor_priority() -> u8

Get the priority for this constructor (higher = preferred) Used when multiple constructors might handle the same definition

impl Serialize for Name

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl ValueObject for Name

fn attribute_type(&self) -> AttributeType

Get the SCIM attribute type this value object represents

fn attribute_name(&self) -> &str

Get the schema attribute name this value object corresponds to

fn to_json(&self) -> ValidationResult<Value>

Serialize the value object to JSON

fn validate_against_schema( &self, definition: &AttributeDefinition, ) -> ValidationResult<()>

Validate the value object against a schema definition

fn as_json_value(&self) -> Value

Get the raw value as a JSON Value for schema-agnostic operations

fn supports_definition(&self, definition: &AttributeDefinition) -> bool

Check if this value object supports the given attribute definition

fn clone_boxed(&self) -> Box<dyn ValueObject>

Clone the value object as a boxed trait object

fn as_any(&self) -> &dyn Any

Get type information for downcasting

impl Eq for Name

impl StructuralPartialEq for Name