Struct twilight_model::guild::Role

source · [−]

pub struct Role {
    pub color: u32,
    pub hoist: bool,
    pub icon: Option<ImageHash>,
    pub id: Id<RoleMarker>,
    pub managed: bool,
    pub mentionable: bool,
    pub name: String,
    pub permissions: Permissions,
    pub position: i64,
    pub tags: Option<RoleTags>,
    pub unicode_emoji: Option<String>,
}

Fields

color: u32hoist: boolicon: Option<ImageHash>

Icon image hash.

Present if the guild has the ROLE_ICONS feature and if the role has one.

See Discord Docs/Image Formatting.

id: Id<RoleMarker>managed: boolmentionable: boolname: Stringpermissions: Permissionsposition: i64tags: Option<RoleTags>

Tags about the role.

unicode_emoji: Option<String>

Icon unicode emoji.

Present if the guild has the ROLE_ICONS feature and if the role has one.

Trait Implementations

source

impl Clone for Role

source

fn clone(&self) -> Role

Returns a copy 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 Role

source

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

Formats the value using the given formatter. Read more

source

impl<'de> Deserialize<'de> for Role

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 Role

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,

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

source

impl Ord for Role

source

fn cmp(&self, other: &Self) -> Ordering

Compare two roles to each other using their position and ID.

Roles are primarily ordered by their position in descending order. For example, a role with a position of 17 is considered a higher role than one with a position of 12.

Discord does not guarantee that role positions are positive, unique, or contiguous. When two or more roles have the same position then the order is based on the roles’ IDs in ascending order. For example, given two roles with positions of 10 then a role with an ID of 1 would be considered a higher role than one with an ID of 20.

Examples

Compare the position of two roles:

let role_a = Role {
    id: Id::new(123),
    position: 12,
    // ...
};
let role_b = Role {
    id: Id::new(456),
    position: 13,
    // ...
};
assert_eq!(Ordering::Less, role_a.cmp(&role_b));
assert_eq!(Ordering::Greater, role_b.cmp(&role_a));
assert_eq!(Ordering::Equal, role_a.cmp(&role_a));
assert_eq!(Ordering::Equal, role_b.cmp(&role_b));

Compare the position of two roles with the same position:

let role_a = Role {
    id: Id::new(123),
    position: 12,
};
let role_b = Role {
    id: Id::new(456),
    position: 12,
};
assert_eq!(Ordering::Less, role_a.cmp(&role_b));
assert_eq!(Ordering::Greater, role_b.cmp(&role_a));
assert_eq!(Ordering::Equal, role_a.cmp(&role_a));
assert_eq!(Ordering::Equal, role_b.cmp(&role_b));