Struct ScimVersion 

pub struct ScimVersion<Format> { /* private fields */ }

Opaque version identifier for SCIM resources with compile-time format safety.

This type uses phantom types to distinguish between HTTP ETag format and raw internal format at compile time, preventing format confusion and runtime errors. The internal representation remains opaque to prevent direct manipulation.

Versions can be created from:

• Provider-specific identifiers (database sequence numbers, timestamps, etc.)
• Content hashes (for stateless version generation)
• String parsing with automatic format detection

Type Safety

The phantom type parameter prevents mixing formats accidentally:

use scim_server::resource::version::{RawVersion, HttpVersion};

let raw_version = RawVersion::from_hash("123");
let http_version: HttpVersion = "W/\"456\"".parse().unwrap();

// This won't compile - cannot pass HttpVersion where RawVersion expected
some_function_expecting_raw(http_version);

Examples

use scim_server::resource::version::{RawVersion, HttpVersion};

// From hash string (always produces Raw format)
let raw_version = RawVersion::from_hash("12345");

// From content hash (always produces Raw format)
let content = br#"{"id":"123","name":"John Doe"}"#;
let hash_version = RawVersion::from_content(content);

// Parse from strings with format detection
let raw_parsed: RawVersion = "abc123def".parse().unwrap();
let http_parsed: HttpVersion = "\"abc123def\"".parse().unwrap();

Implementations

impl<Format> ScimVersion<Format>

pub fn from_content(content: &[u8]) -> RawVersion

Create a version from resource content.

This generates a deterministic hash-based version from the resource content, ensuring universal compatibility across all provider implementations. The version is based on the full resource content including all fields.

Always produces a RawVersion as content hashing creates canonical versions.

Arguments

• content - The complete resource content as bytes

Examples

use scim_server::resource::version::RawVersion;

let resource_json = br#"{"id":"123","userName":"john.doe"}"#;
let version = RawVersion::from_content(resource_json);

pub fn from_hash(hash_string: impl AsRef<str>) -> RawVersion

Create a version from a pre-computed hash string.

This is useful for provider-specific versioning schemes such as database sequence numbers, timestamps, or UUIDs. The provider can use any string as a version identifier.

Always produces a RawVersion as the canonical internal format.

Arguments

• hash_string - Provider-specific version identifier

Examples

use scim_server::resource::version::RawVersion;

// Database sequence number
let db_version = RawVersion::from_hash("seq_12345");

// Timestamp-based version
let time_version = RawVersion::from_hash("1703123456789");

// UUID-based version
let uuid_version = RawVersion::from_hash("550e8400-e29b-41d4-a716-446655440000");

pub fn as_str(&self) -> &str

Get the opaque version string.

This is primarily for internal use and debugging. The opaque string should not be relied upon for any business logic outside of equality comparisons.

Trait Implementations

impl<Format: Clone> Clone for ScimVersion<Format>

fn clone(&self) -> ScimVersion<Format>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Format: Debug> Debug for ScimVersion<Format>

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

Formats the value using the given formatter.

impl<'de, Format> Deserialize<'de> for ScimVersion<Format>

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ScimVersion<Http>

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

Formats the value using the given formatter.

impl Display for ScimVersion<Raw>

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

Formats the value using the given formatter.

impl From<ScimVersion<Http>> for ScimVersion<Raw>

fn from(http: ScimVersion<Http>) -> Self

Converts to this type from the input type.

impl From<ScimVersion<Raw>> for ScimVersion<Http>

fn from(raw: ScimVersion<Raw>) -> Self

Converts to this type from the input type.

impl FromStr for ScimVersion<Http>

type Err = VersionError

The associated error which can be returned from parsing.

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

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

impl FromStr for ScimVersion<Raw>

type Err = VersionError

The associated error which can be returned from parsing.

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

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

impl<Format: Hash> Hash for ScimVersion<Format>

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<F1, F2> PartialEq<ScimVersion<F2>> for ScimVersion<F1>

fn eq(&self, other: &ScimVersion<F2>) -> 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<Format> Serialize for ScimVersion<Format>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<Format: Eq> Eq for ScimVersion<Format>