Struct MultiValuedAttribute 

pub struct MultiValuedAttribute<T> { /* private fields */ }

A generic container for multi-valued SCIM attributes.

This type provides type-safe handling of multi-valued attributes with support for designating one value as primary. It enforces the SCIM constraint that at most one value can be marked as primary.

Type Parameters

• T - The type of values contained in the multi-valued attribute

Examples

use scim_server::resource::value_objects::{MultiValuedAttribute, EmailAddress};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let emails = vec![
        EmailAddress::new_simple("work@example.com".to_string())?,
        EmailAddress::new_simple("personal@example.com".to_string())?,
    ];

    let multi_emails = MultiValuedAttribute::new(emails)?;
    assert_eq!(multi_emails.len(), 2);
    assert!(multi_emails.primary().is_none());
    Ok(())
}

Implementations

impl<T> MultiValuedAttribute<T>

pub fn new(values: Vec<T>) -> ValidationResult<Self>

Creates a new multi-valued attribute from a collection of values.

Arguments

• values - Vector of values to store

Returns

• Ok(MultiValuedAttribute<T>) - Successfully created multi-valued attribute
• Err(ValidationError) - If the input is invalid (e.g., empty vector)

Examples

use scim_server::resource::value_objects::{MultiValuedAttribute, EmailAddress};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let emails = vec![
        EmailAddress::new_simple("work@example.com".to_string())?,
        EmailAddress::new_simple("personal@example.com".to_string())?,
    ];
    let multi_emails = MultiValuedAttribute::new(emails)?;
    Ok(())
}

pub fn single(value: T) -> Self

Creates a new multi-valued attribute with a single value.

Arguments

• value - Single value to store

Returns

A multi-valued attribute containing the single value

Examples

use scim_server::resource::value_objects::{MultiValuedAttribute, EmailAddress};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let email = EmailAddress::new_simple("user@example.com".to_string())?;
    let multi_email = MultiValuedAttribute::single(email);
    assert_eq!(multi_email.len(), 1);
    Ok(())
}

pub fn single_primary(value: T) -> Self

Creates a new multi-valued attribute with a single primary value.

Arguments

• value - Single value to store as primary

Returns

A multi-valued attribute containing the single primary value

Examples

use scim_server::resource::value_objects::{MultiValuedAttribute, EmailAddress};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let email = EmailAddress::new_simple("primary@example.com".to_string())?;
    let multi_email = MultiValuedAttribute::single_primary(email);
    assert!(multi_email.primary().is_some());
    Ok(())
}

pub fn len(&self) -> usize

Returns the number of values in the collection.

Examples

use scim_server::resource::value_objects::{MultiValuedAttribute, EmailAddress};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let emails = vec![
        EmailAddress::new_simple("work@example.com".to_string())?,
        EmailAddress::new_simple("personal@example.com".to_string())?,
    ];
    let multi_attr = MultiValuedAttribute::new(emails)?;
    assert_eq!(multi_attr.len(), 2);
    Ok(())
}

pub fn is_empty(&self) -> bool

Returns true if the collection is empty.

Examples

use scim_server::resource::value_objects::{MultiValuedAttribute, EmailAddress};

let multi_attr = MultiValuedAttribute::single(
    EmailAddress::new_simple("test@example.com".to_string()).unwrap()
);
assert!(!multi_attr.is_empty());

pub fn primary(&self) -> Option<&T>

Returns a reference to the primary value, if one is set.

Returns

• Some(&T) - Reference to the primary value
• None - No primary value is set

Examples

use scim_server::resource::value_objects::{MultiValuedAttribute, EmailAddress};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let emails = vec![
        EmailAddress::new_simple("work@example.com".to_string())?,
        EmailAddress::new_simple("personal@example.com".to_string())?,
    ];
    let multi_attr = MultiValuedAttribute::new(emails)?.with_primary(0)?;
    if let Some(primary) = multi_attr.primary() {
        println!("Primary value found");
    }
    Ok(())
}

pub fn primary_index(&self) -> Option<usize>

Returns the index of the primary value, if one is set.

Returns

• Some(usize) - Index of the primary value
• None - No primary value is set

pub fn values(&self) -> &[T]

Returns a reference to all values in the collection.

Examples

use scim_server::resource::value_objects::{MultiValuedAttribute, EmailAddress};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let emails = vec![
        EmailAddress::new_simple("work@example.com".to_string())?,
        EmailAddress::new_simple("personal@example.com".to_string())?,
    ];
    let multi_attr = MultiValuedAttribute::new(emails)?;
    for value in multi_attr.values() {
        println!("Value: {:?}", value);
    }
    Ok(())
}

pub fn get(&self, index: usize) -> Option<&T>

Returns a reference to the value at the specified index.

Arguments

• index - Index of the value to retrieve

Returns

• Some(&T) - Reference to the value at the index
• None - Index is out of bounds

pub fn with_primary(self, index: usize) -> ValidationResult<Self>

Creates a new multi-valued attribute with the specified value set as primary.

Arguments

• index - Index of the value to set as primary

Returns

• Ok(MultiValuedAttribute<T>) - New instance with primary value set
• Err(ValidationError) - If the index is out of bounds

Examples

use scim_server::resource::value_objects::{MultiValuedAttribute, EmailAddress};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let emails = vec![
        EmailAddress::new_simple("work@example.com".to_string())?,
        EmailAddress::new_simple("personal@example.com".to_string())?,
    ];
    let multi_attr = MultiValuedAttribute::new(emails)?;
    let with_primary = multi_attr.with_primary(0)?;
    assert!(with_primary.primary().is_some());
    Ok(())
}

pub fn without_primary(self) -> Self

Creates a new multi-valued attribute with no primary value set.

Examples

use scim_server::resource::value_objects::{MultiValuedAttribute, EmailAddress};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let emails = vec![
        EmailAddress::new_simple("work@example.com".to_string())?,
        EmailAddress::new_simple("personal@example.com".to_string())?,
    ];
    let multi_attr = MultiValuedAttribute::new(emails)?.with_primary(0)?;
    let without_primary = multi_attr.without_primary();
    assert!(without_primary.primary().is_none());
    Ok(())
}

pub fn with_value(self, value: T) -> Self

Creates a new multi-valued attribute with an additional value.

Arguments

• value - Value to add to the collection

Returns

A new multi-valued attribute with the added value

Examples

use scim_server::resource::value_objects::{MultiValuedAttribute, EmailAddress};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let emails = vec![
        EmailAddress::new_simple("work@example.com".to_string())?,
    ];
    let multi_attr = MultiValuedAttribute::new(emails)?;
    let new_email = EmailAddress::new_simple("personal@example.com".to_string())?;
    let with_value = multi_attr.with_value(new_email);
    assert_eq!(with_value.len(), 2);
    Ok(())
}

pub fn with_primary_value(self, value: T) -> Self

Creates a new multi-valued attribute with an additional primary value.

This method adds the value and sets it as the primary value.

Arguments

• value - Value to add as primary

Returns

A new multi-valued attribute with the added primary value

Examples

use scim_server::resource::value_objects::{MultiValuedAttribute, EmailAddress};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let emails = vec![
        EmailAddress::new_simple("work@example.com".to_string())?,
    ];
    let multi_attr = MultiValuedAttribute::new(emails)?;
    let new_email = EmailAddress::new_simple("primary@example.com".to_string())?;
    let with_primary = multi_attr.with_primary_value(new_email.clone());
    assert_eq!(with_primary.primary(), Some(&new_email));
    Ok(())
}

pub fn iter(&self) -> Iter<'_, T>

Returns an iterator over the values in the collection.

Examples

use scim_server::resource::value_objects::{MultiValuedAttribute, EmailAddress};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let emails = vec![
        EmailAddress::new_simple("work@example.com".to_string())?,
        EmailAddress::new_simple("personal@example.com".to_string())?,
    ];
    let multi_attr = MultiValuedAttribute::new(emails)?;
    for value in multi_attr.iter() {
        println!("Value: {:?}", value);
    }
    Ok(())
}

pub fn validate_single_primary(&self) -> ValidationResult<()>

Validates that at most one value is marked as primary.

This method is primarily used internally to ensure invariants are maintained during construction and modification.

Returns

• Ok(()) - Validation passed
• Err(ValidationError) - Multiple primary values detected

pub fn find<P>(&self, predicate: P) -> Option<&T>

where P: Fn(&T) -> bool,

Finds the first value that matches the given predicate.

Arguments

• predicate - Function to test each value

Returns

• Some(&T) - Reference to the first matching value
• None - No value matches the predicate

Examples

use scim_server::resource::value_objects::{MultiValuedAttribute, EmailAddress};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let emails = vec![
        EmailAddress::new_simple("work@example.com".to_string())?,
        EmailAddress::new_simple("personal@example.com".to_string())?,
    ];
    let multi_attr = MultiValuedAttribute::new(emails)?;
    let found = multi_attr.find(|value| value.value().contains("work"));
    assert!(found.is_some());
    Ok(())
}

pub fn filter<P>(&self, predicate: P) -> Vec<&T>

where P: Fn(&T) -> bool,

Returns all values that satisfy the given predicate. Filters values that match the given predicate.

Arguments

• predicate - Function to test each value

Returns

An iterator over references to matching values

Examples

use scim_server::resource::value_objects::{MultiValuedAttribute, EmailAddress};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let emails = vec![
        EmailAddress::new_simple("work@example.com".to_string())?,
        EmailAddress::new_simple("personal@example.com".to_string())?,
    ];
    let multi_attr = MultiValuedAttribute::new(emails)?;
    let work_values = multi_attr.filter(|v| v.value().contains("work"));
    assert_eq!(work_values.len(), 1);
    Ok(())
}

pub fn into_values(self) -> Vec<T>

Converts the multi-valued attribute into a vector of values.

This consumes the multi-valued attribute and returns the underlying vector.

Examples

use scim_server::resource::value_objects::{MultiValuedAttribute, EmailAddress};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let emails = vec![
        EmailAddress::new_simple("work@example.com".to_string())?,
        EmailAddress::new_simple("personal@example.com".to_string())?,
    ];
    let multi_attr = MultiValuedAttribute::new(emails)?;
    let values_vec = multi_attr.into_values();
    assert_eq!(values_vec.len(), 2);
    Ok(())
}

Trait Implementations

impl<T: Clone> Clone for MultiValuedAttribute<T>

fn clone(&self) -> MultiValuedAttribute<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for MultiValuedAttribute<T>

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

Formats the value using the given formatter.

impl<T> Default for MultiValuedAttribute<T>

fn default() -> Self

Creates an empty multi-valued attribute.

Note: This creates an empty collection which may not be valid for all use cases. Use new() for validated construction.

impl<'de, T> Deserialize<'de> for MultiValuedAttribute<T>

where T: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Display> Display for MultiValuedAttribute<T>

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

Formats the multi-valued attribute for display.

Shows the number of values and indicates which one is primary.

impl<T> From<T> for MultiValuedAttribute<T>

fn from(value: T) -> Self

Creates a multi-valued attribute from a single value.

impl<T> From<Vec<T>> for MultiValuedAttribute<T>

fn from(values: Vec<T>) -> Self

Creates a multi-valued attribute from a vector of values.

This bypasses validation and should be used carefully. Consider using new() for validated construction.

impl<'a, T> IntoIterator for &'a MultiValuedAttribute<T>

fn into_iter(self) -> Self::IntoIter

Creates an iterator that yields borrowed values.

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for MultiValuedAttribute<T>

fn into_iter(self) -> Self::IntoIter

Creates an iterator that yields owned values.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

impl<T: PartialEq> PartialEq for MultiValuedAttribute<T>

fn eq(&self, other: &MultiValuedAttribute<T>) -> 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<T> Serialize for MultiValuedAttribute<T>

where T: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> StructuralPartialEq for MultiValuedAttribute<T>