UserMapping

signstar_config::config::mapping

Enum UserMapping 

Source 
pub enum UserMapping {
    NetHsmOnlyAdmin(UserId),
    SystemNetHsmBackup {
        nethsm_user: SystemWideUserId,
        ssh_authorized_key: AuthorizedKeyEntry,
        system_user: SystemUserId,
    },
    SystemNetHsmMetrics {
        nethsm_users: NetHsmMetricsUsers,
        ssh_authorized_key: AuthorizedKeyEntry,
        system_user: SystemUserId,
    },
    SystemNetHsmOperatorSigning {
        nethsm_user: UserId,
        key_id: KeyId,
        nethsm_key_setup: SigningKeySetup,
        ssh_authorized_key: AuthorizedKeyEntry,
        system_user: SystemUserId,
        tag: String,
    },
    HermeticSystemNetHsmMetrics {
        nethsm_users: NetHsmMetricsUsers,
        system_user: SystemUserId,
    },
    SystemOnlyShareDownload {
        system_user: SystemUserId,
        ssh_authorized_key: AuthorizedKeyEntry,
    },
    SystemOnlyShareUpload {
        system_user: SystemUserId,
        ssh_authorized_key: AuthorizedKeyEntry,
    },
    SystemOnlyWireGuardDownload {
        system_user: SystemUserId,
        ssh_authorized_key: AuthorizedKeyEntry,
    },
}
Expand description

User and data mapping between system users and HSM users.

Variants§

§

NetHsmOnlyAdmin(UserId)

A NetHsm user in the Administrator role, without a system user mapped to it

§

SystemNetHsmBackup

A system user, with SSH access, mapped to a system-wide NetHSM user in the Backup role.

Fields

§nethsm_user: SystemWideUserId

The name of the NetHSM user.

§ssh_authorized_key: AuthorizedKeyEntry

The SSH public key used for connecting to the system_user.

§system_user: SystemUserId

The name of the system user.

§

SystemNetHsmMetrics

A system user, with SSH access, mapped to a system-wide NetHSM user in the Metrics role and n users in the Operator role with read-only access to zero or more keys

Fields

§nethsm_users: NetHsmMetricsUsers

The NetHSM users in the [Metrics][UserRole::Metrics] and [operator][UserRole::Operator] role.

§ssh_authorized_key: AuthorizedKeyEntry

The SSH public key used for connecting to the system_user.

§system_user: SystemUserId

The name of the system user.

§

SystemNetHsmOperatorSigning

A system user, with SSH access, mapped to a NetHSM user in the Operator role with access to a single signing key.

Signing key and NetHSM user are mapped using a tag.

Fields

§nethsm_user: UserId

The name of the NetHSM user.

§key_id: KeyId

The ID of the NetHSM key.

§nethsm_key_setup: SigningKeySetup

The setup of a NetHSM key.

§ssh_authorized_key: AuthorizedKeyEntry

The SSH public key used for connecting to the system_user.

§system_user: SystemUserId

The name of the system user.

§tag: String

The tag used for the user and the signing key on the NetHSM.

§

HermeticSystemNetHsmMetrics

A system user, without SSH access, mapped to a system-wide NetHSM user in the Metrics role and one or more NetHsm users in the Operator role with read-only access to zero or more keys

Fields

§nethsm_users: NetHsmMetricsUsers

The NetHSM users in the [Metrics][UserRole::Metrics] and [operator][UserRole::Operator] role.

§system_user: SystemUserId

The name of the system user.

§

SystemOnlyShareDownload

A system user, with SSH access, not mapped to any backend user, that is used for downloading shares of a shared secret.

Fields

§system_user: SystemUserId

The name of the system user.

§ssh_authorized_key: AuthorizedKeyEntry

The list of SSH public keys used for connecting to the system_user.

§

SystemOnlyShareUpload

A system user, with SSH access, not mapped to any backend user, that is used for uploading shares of a shared secret.

Fields

§system_user: SystemUserId

The name of the system user.

§ssh_authorized_key: AuthorizedKeyEntry

The list of SSH public keys used for connecting to the system_user.

§

SystemOnlyWireGuardDownload

A system user, with SSH access, not mapped to any backend user, that is used for downloading the WireGuard configuration of the host.

Fields

§system_user: SystemUserId

The name of the system user.

§ssh_authorized_key: AuthorizedKeyEntry

The list of SSH public keys used for connecting to the system_user.

Implementations§

Source§

impl UserMapping

Source

pub fn get_system_user(&self) -> Option<&SystemUserId>

Returns the optional system user of the mapping

§Examples
use signstar_config::{SystemUserId, UserMapping};

let mapping = UserMapping::SystemOnlyShareDownload {
    system_user: "user1".parse()?,
    ssh_authorized_key: "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIH3NyNfSqtDxdnWwSVzulZi0k7Lyjw3vBEG+U8y6KsuW user@host".parse()?,
};
assert_eq!(mapping.get_system_user(), Some(&SystemUserId::new("user1".to_string())?));

let mapping = UserMapping::NetHsmOnlyAdmin("user1".parse()?);
assert_eq!(mapping.get_system_user(), None);
Source

pub fn backend_users(&self, filter: UserMappingFilter) -> Vec<String>

Returns the backend users of the mapping.

Returns a Vec of String containing all backend user names.

§Examples
use signstar_crypto::{key::{CryptographicKeyContext, SigningKeySetup}, openpgp::OpenPgpUserIdList};
use signstar_config::{BackendUserKind, UserMapping, UserMappingFilter};

let mapping = UserMapping::SystemNetHsmOperatorSigning {
    nethsm_user: "user1".parse()?,
    key_id: "key1".parse()?,
    nethsm_key_setup: SigningKeySetup::new(
        "Curve25519".parse()?,
        vec!["EdDsaSignature".parse()?],
        None,
        "EdDsa".parse()?,
        CryptographicKeyContext::OpenPgp{
            user_ids: OpenPgpUserIdList::new(vec!["John Doe <john@example.org>".parse()?])?,
            version: "v4".parse()?,
        },
    )?,
    system_user: "ssh-user1".parse()?,
    ssh_authorized_key: "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIH3NyNfSqtDxdnWwSVzulZi0k7Lyjw3vBEG+U8y6KsuW user@host".parse()?,
    tag: "tag1".to_string(),
};
assert_eq!(vec!["user1".to_string()], mapping.backend_users(UserMappingFilter::default()));

let mapping = UserMapping::NetHsmOnlyAdmin("user1".parse()?);
assert_eq!(vec!["user1".to_string()], mapping.backend_users(UserMappingFilter{ backend_user_kind: BackendUserKind::Admin }));
Source

pub fn backend_users_with_new_passphrase( &self, filter: UserMappingFilter, ) -> Vec<Box<dyn UserWithPassphrase>>

Returns the backend users of the mapping with new passphrases based on a filter.

Returns a Vec of implementations of the UserWithPassphrase trait. For each returned backend user a new Passphrase is generated using the default settings of Passphrase::generate.

With a UserMappingFilter it is possible to target specific kinds of backend users.

§Examples
use signstar_crypto::{key::{CryptographicKeyContext, SigningKeySetup}, openpgp::OpenPgpUserIdList};
use signstar_config::{UserMapping, UserMappingFilter};

let mapping = UserMapping::SystemNetHsmOperatorSigning {
    nethsm_user: "user1".parse()?,
    key_id: "key1".parse()?,
    nethsm_key_setup: SigningKeySetup::new(
        "Curve25519".parse()?,
        vec!["EdDsaSignature".parse()?],
        None,
        "EdDsa".parse()?,
        CryptographicKeyContext::OpenPgp{
            user_ids: OpenPgpUserIdList::new(vec!["John Doe <john@example.org>".parse()?])?,
            version: "v4".parse()?,
        },
    )?,
    system_user: "ssh-user1".parse()?,
    ssh_authorized_key: "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIH3NyNfSqtDxdnWwSVzulZi0k7Lyjw3vBEG+U8y6KsuW user@host".parse()?,
    tag: "tag1".to_string(),
};
let creds = mapping.backend_users_with_new_passphrase(UserMappingFilter::default());
println!("{creds:?}");

let mapping = UserMapping::NetHsmOnlyAdmin("user1".parse()?);
let creds = mapping.backend_users_with_new_passphrase(UserMappingFilter::default());
println!("{creds:?}");
Source

pub fn get_nethsm_users(&self) -> Vec<UserId>

Returns the NetHSM users of the mapping

§Examples
use nethsm::UserId;
use signstar_config::UserMapping;

let mapping = UserMapping::SystemOnlyShareDownload {
    system_user: "user1".parse()?,
    ssh_authorized_key: "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIH3NyNfSqtDxdnWwSVzulZi0k7Lyjw3vBEG+U8y6KsuW user@host".parse()?,
};
assert!(mapping.get_nethsm_users().is_empty());

let mapping = UserMapping::NetHsmOnlyAdmin("user1".parse()?);
assert_eq!(mapping.get_nethsm_users(), vec![UserId::new("user1".to_string())?]);
Source

pub fn get_nethsm_users_and_roles(&self) -> Vec<(UserId, UserRole)>

Returns the list of all tracked [UserId]s and their respective [UserRole]s.

§Examples
use nethsm::{UserId, UserRole};
use signstar_config::UserMapping;

let mapping = UserMapping::SystemOnlyShareDownload {
    system_user: "user1".parse()?,
    ssh_authorized_key: "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIH3NyNfSqtDxdnWwSVzulZi0k7Lyjw3vBEG+U8y6KsuW user@host".parse()?,
};
assert!(mapping.get_nethsm_users_and_roles().is_empty());

let mapping = UserMapping::NetHsmOnlyAdmin("user1".parse()?);
assert_eq!(mapping.get_nethsm_users_and_roles(), vec![(UserId::new("user1".to_string())?, UserRole::Administrator)]);
Source

pub fn get_nethsm_user_role_and_tags( &self, ) -> Vec<(UserId, UserRole, Vec<String>)>

Returns a list of tuples containing [UserId], [UserRole] and a list of tags.

§Note

Certain variants of UserMapping such as UserMapping::SystemOnlyShareDownload, UserMapping::SystemOnlyShareUpload and UserMapping::SystemOnlyWireGuardDownload always return an empty Vec because they do not track backend users.

§Examples
use nethsm::{CryptographicKeyContext, OpenPgpUserIdList, UserId, UserRole};
use signstar_crypto::key::SigningKeySetup;
use signstar_config::{AuthorizedKeyEntry, UserMapping};

let mapping = UserMapping::SystemNetHsmOperatorSigning {
    nethsm_user: "user1".parse()?,
    key_id: "key1".parse()?,
    nethsm_key_setup: SigningKeySetup::new(
        "Curve25519".parse()?,
        vec!["EdDsaSignature".parse()?],
        None,
        "EdDsa".parse()?,
        CryptographicKeyContext::OpenPgp{
            user_ids: OpenPgpUserIdList::new(vec!["John Doe <john@example.org>".parse()?])?,
            version: "v4".parse()?,
        },
    )?,
    system_user: "ssh-user1".parse()?,
    ssh_authorized_key: "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIH3NyNfSqtDxdnWwSVzulZi0k7Lyjw3vBEG+U8y6KsuW user@host".parse()?,
    tag: "tag1".to_string(),
};
assert_eq!(
    mapping.get_nethsm_user_role_and_tags(),
    vec![(UserId::new("user1".to_string())?, UserRole::Operator, vec!["tag1".to_string()])]);
Source

pub fn get_ssh_authorized_key(&self) -> Option<&AuthorizedKeyEntry>

Returns the SSH authorized key of the mapping if it exists.

Returns None if the mapping does not have an SSH authorized key.

§Examples
use std::str::FromStr;

use signstar_config::{AuthorizedKeyEntry, UserMapping};

let mapping = UserMapping::SystemOnlyShareDownload {
    system_user: "user1".parse()?,
    ssh_authorized_key: "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIH3NyNfSqtDxdnWwSVzulZi0k7Lyjw3vBEG+U8y6KsuW user@host".parse()?,
};
assert_eq!(mapping.get_ssh_authorized_key(), Some(&AuthorizedKeyEntry::from_str("ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIH3NyNfSqtDxdnWwSVzulZi0k7Lyjw3vBEG+U8y6KsuW user@host")?));

let mapping = UserMapping::NetHsmOnlyAdmin("user1".parse()?);
assert_eq!(mapping.get_ssh_authorized_key(), None);
Source

pub fn get_nethsm_key_ids(&self, namespace: Option<&NamespaceId>) -> Vec<KeyId>

Returns all used [KeyId]s of the mapping

§Examples
use nethsm::{CryptographicKeyContext, KeyId, OpenPgpUserIdList};
use signstar_crypto::key::SigningKeySetup;
use signstar_config::{AuthorizedKeyEntry, UserMapping};

let mapping = UserMapping::SystemNetHsmOperatorSigning {
    nethsm_user: "user1".parse()?,
    key_id: "key1".parse()?,
    nethsm_key_setup: SigningKeySetup::new(
        "Curve25519".parse()?,
        vec!["EdDsaSignature".parse()?],
        None,
        "EdDsa".parse()?,
        CryptographicKeyContext::OpenPgp{
            user_ids: OpenPgpUserIdList::new(vec!["John Doe <john@example.org>".parse()?])?,
            version: "v4".parse()?,
        },
    )?,
    system_user: "ssh-user1".parse()?,
    ssh_authorized_key: "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIH3NyNfSqtDxdnWwSVzulZi0k7Lyjw3vBEG+U8y6KsuW user@host".parse()?,
    tag: "tag1".to_string(),
};
assert_eq!(mapping.get_nethsm_key_ids(None), vec![KeyId::new("key1".to_string())?]);

let mapping = UserMapping::SystemOnlyShareDownload {
    system_user: "user1".parse()?,
    ssh_authorized_key: "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIH3NyNfSqtDxdnWwSVzulZi0k7Lyjw3vBEG+U8y6KsuW user@host".parse()?,
};
assert_eq!(mapping.get_nethsm_key_ids(None), Vec::new());
Source

pub fn get_nethsm_tags(&self, namespace: Option<&NamespaceId>) -> Vec<&str>

Returns tags for keys and users

Tags can be filtered by namespace by providing Some namespace. Providing None implies that the context is system-wide.

§Examples
use nethsm::{CryptographicKeyContext, OpenPgpUserIdList};
use signstar_crypto::key::SigningKeySetup;
use signstar_config::UserMapping;

let mapping = UserMapping::SystemOnlyShareDownload {
    system_user: "user1".parse()?,
    ssh_authorized_key: "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIH3NyNfSqtDxdnWwSVzulZi0k7Lyjw3vBEG+U8y6KsuW user@host".parse()?,
};
assert!(mapping.get_nethsm_tags(None).is_empty());

let mapping = UserMapping::NetHsmOnlyAdmin("user1".parse()?);
assert!(mapping.get_nethsm_tags(None).is_empty());

let mapping = UserMapping::SystemNetHsmOperatorSigning{
    nethsm_user: "ns1~user1".parse()?,
    key_id: "key1".parse()?,
    nethsm_key_setup: SigningKeySetup::new(
        "Curve25519".parse()?,
        vec!["EdDsaSignature".parse()?],
        None,
        "EdDsa".parse()?,
        CryptographicKeyContext::OpenPgp{
            user_ids: OpenPgpUserIdList::new(vec!["John Doe <john@example.org>".parse()?])?,
            version: "4".parse()?,
    })?,
    system_user: "user1".parse()?,
    ssh_authorized_key: "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIH3NyNfSqtDxdnWwSVzulZi0k7Lyjw3vBEG+U8y6KsuW user@host".parse()?,
    tag: "tag1".to_string(),
};
assert!(mapping.get_nethsm_tags(None).is_empty());
assert_eq!(mapping.get_nethsm_tags(Some(&"ns1".parse()?)), vec!["tag1"]);
Source

pub fn get_nethsm_user_key_and_tag( &self, filter: FilterUserKeys, ) -> Vec<(UserId, KeyId, SigningKeySetup, String)>

Returns a list of tuples of [UserId], [KeyId], SigningKeySetup and tag for the mapping.

Using a filter (see FilterUserKeys) it is possible to have only a subset of the available tuples be returned:

§Examples
use nethsm::{CryptographicKeyContext, KeyId, OpenPgpUserIdList, UserId};
use signstar_crypto::key::SigningKeySetup;
use signstar_config::{FilterUserKeys, UserMapping};

let mapping = UserMapping::SystemNetHsmOperatorSigning {
    nethsm_user: "user1".parse()?,
    key_id: "key1".parse()?,
    nethsm_key_setup: SigningKeySetup::new(
        "Curve25519".parse()?,
        vec!["EdDsaSignature".parse()?],
        None,
        "EdDsa".parse()?,
        CryptographicKeyContext::OpenPgp{
            user_ids: OpenPgpUserIdList::new(vec!["John Doe <john@example.org>".parse()?])?,
            version: "v4".parse()?,
        },
    )?,
    system_user: "ssh-user1".parse()?,
    ssh_authorized_key: "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIH3NyNfSqtDxdnWwSVzulZi0k7Lyjw3vBEG+U8y6KsuW user@host".parse()?,
    tag: "tag1".to_string(),
};
assert_eq!(
    mapping.get_nethsm_user_key_and_tag(FilterUserKeys::All),
    vec![(
        "user1".parse()?,
        "key1".parse()?,
        SigningKeySetup::new(
            "Curve25519".parse()?,
            vec!["EdDsaSignature".parse()?],
            None,
            "EdDsa".parse()?,
            CryptographicKeyContext::OpenPgp{
                user_ids: OpenPgpUserIdList::new(vec!["John Doe <john@example.org>".parse()?])?,
                version: "v4".parse()?,
            },
        )?,
        "tag1".to_string(),
    )]
);
assert_eq!(mapping.get_nethsm_user_key_and_tag(FilterUserKeys::Namespace("test".parse()?)), Vec::new());
assert_eq!(mapping.get_nethsm_user_key_and_tag(FilterUserKeys::Tag("tag2".parse()?)), Vec::new());

let mapping = UserMapping::SystemOnlyShareDownload {
    system_user: "user1".parse()?,
    ssh_authorized_key: "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIH3NyNfSqtDxdnWwSVzulZi0k7Lyjw3vBEG+U8y6KsuW user@host".parse()?,
};
assert_eq!(mapping.get_nethsm_user_key_and_tag(FilterUserKeys::All), Vec::new());
Source

pub fn get_nethsm_namespaces(&self) -> Vec<NamespaceId>

Returns all NetHSM namespaces of the mapping.

§Examples
use nethsm::{CryptographicKeyContext, OpenPgpUserIdList};
use signstar_crypto::key::SigningKeySetup;
use signstar_config::UserMapping;

let mapping = UserMapping::SystemOnlyShareDownload {
    system_user: "user1".parse()?,
    ssh_authorized_key: "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIH3NyNfSqtDxdnWwSVzulZi0k7Lyjw3vBEG+U8y6KsuW user@host".parse()?,
};
assert!(mapping.get_nethsm_namespaces().is_empty());

let mapping = UserMapping::NetHsmOnlyAdmin("user1".parse()?);
assert!(mapping.get_nethsm_namespaces().is_empty());

let mapping = UserMapping::SystemNetHsmOperatorSigning{
    nethsm_user: "ns1~user1".parse()?,
    key_id: "key1".parse()?,
    nethsm_key_setup: SigningKeySetup::new(
        "Curve25519".parse()?,
        vec!["EdDsaSignature".parse()?],
        None,
        "EdDsa".parse()?,
        CryptographicKeyContext::OpenPgp{
            user_ids: OpenPgpUserIdList::new(vec!["John Doe <john@example.org>".parse()?])?,
            version: "4".parse()?,
    })?,
    system_user: "user1".parse()?,
    ssh_authorized_key: "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIH3NyNfSqtDxdnWwSVzulZi0k7Lyjw3vBEG+U8y6KsuW user@host".parse()?,
    tag: "tag1".to_string(),
};
assert_eq!(mapping.get_nethsm_namespaces(), vec!["ns1".parse()?]);
Source

pub fn has_system_and_backend_user(&self) -> bool

Returns whether the mapping has both system and HSM backend users.

Returns true if the self has at least one system and one HSM backend user, and false otherwise.

Trait Implementations§

Source§

impl Clone for UserMapping

Source§

fn clone(&self) -> UserMapping

Returns a duplicate of the value. Read more
1.0.0 · Source§

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

Performs copy-assignment from source. Read more
Source§

impl Debug for UserMapping

Source§

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

Formats the value using the given formatter. Read more
Source§

impl<'de> Deserialize<'de> for UserMapping

Source§

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>
where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
Source§

impl Hash for UserMapping

Source§

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

Feeds this value into the given Hasher. Read more
1.3.0 · Source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
Source§

impl PartialEq for UserMapping

Source§

fn eq(&self, other: &UserMapping) -> bool

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Source§

impl Serialize for UserMapping

Source§

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

Serialize this value into the given Serde serializer. Read more
Source§

impl Eq for UserMapping

Source§

impl StructuralPartialEq for UserMapping

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
§

impl<T> Conv for T

§

fn conv<T>(self) -> T
where Self: Into<T>,

Converts self into T using Into<T>. Read more
§

impl<T> FmtForward for T

§

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

Causes self to use its Binary implementation when Debug-formatted.
§

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

Causes self to use its Display implementation when Debug-formatted.
§

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

Causes self to use its LowerExp implementation when Debug-formatted.
§

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

Causes self to use its LowerHex implementation when Debug-formatted.
§

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

Causes self to use its Octal implementation when Debug-formatted.
§

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

Causes self to use its Pointer implementation when Debug-formatted.
§

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

Causes self to use its UpperExp implementation when Debug-formatted.
§

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

Causes self to use its UpperHex implementation when Debug-formatted.
§

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

Formats each item in a sequence. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

§

impl<T> Pipe for T
where T: ?Sized,

§

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

Pipes by value. This is generally the method you want to use. Read more
§

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

Borrows self and passes that borrow into the pipe function. Read more
§

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

Mutably borrows self and passes that borrow into the pipe function. Read more
§

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

Borrows self, then passes self.borrow() into the pipe function. Read more
§

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more
§

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

Borrows self, then passes self.as_ref() into the pipe function.
§

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.as_mut() into the pipe function.
§

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

Borrows self, then passes self.deref() into the pipe function.
§

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.deref_mut() into the pipe function.
Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
§

impl<T> Tap for T

§

fn tap(self, func: impl FnOnce(&Self)) -> Self

Immutable access to a value. Read more
§

fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

Mutable access to a value. Read more
§

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Immutable access to the Borrow<B> of a value. Read more
§

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Mutable access to the BorrowMut<B> of a value. Read more
§

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Immutable access to the AsRef<R> view of a value. Read more
§

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Mutable access to the AsMut<R> view of a value. Read more
§

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Immutable access to the Deref::Target of a value. Read more
§

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Mutable access to the Deref::Target of a value. Read more
§

fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

Calls .tap() only in debug builds, and is erased in release builds.
§

fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

Calls .tap_mut() only in debug builds, and is erased in release builds.
§

fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Calls .tap_borrow() only in debug builds, and is erased in release builds.
§

fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds.
§

fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Calls .tap_ref() only in debug builds, and is erased in release builds.
§

fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Calls .tap_ref_mut() only in debug builds, and is erased in release builds.
§

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Calls .tap_deref() only in debug builds, and is erased in release builds.
§

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Calls .tap_deref_mut() only in debug builds, and is erased in release builds.
Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
§

impl<T> TryConv for T

§

fn try_conv<T>(self) -> Result<T, Self::Error>
where Self: TryInto<T>,

Attempts to convert self into T using TryInto<T>. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

Source§

impl<T> DeserializeOwned for T
where T: for<'de> Deserialize<'de>,

§

impl<T> ErasedDestructor for T
where T: 'static,