Struct Name 

pub struct Name { /* private fields */ }

Component providing a human-readable name for an entity.

Names are useful for:

• Debugging and logging
• Editor integration and scene hierarchies
• Scripting references (find entity by name)
• UI display

Performance

Names use Rust’s String type internally. For performance-critical code, consider using entity IDs directly rather than string lookups.

Example

use goud_engine::ecs::components::Name;

let name = Name::new("Player");
assert_eq!(name.as_str(), "Player");

let mut name = Name::new("Enemy");
name.set("Boss");
assert_eq!(name.as_str(), "Boss");

Implementations

impl Name

pub fn new(name: impl Into<String>) -> Name

Creates a new Name component with the given string.

Arguments

• name - The name string (anything that can be converted to String)

Example

use goud_engine::ecs::components::Name;

let name = Name::new("Player");
let name2 = Name::new(String::from("Enemy"));

pub fn as_str(&self) -> &str

Returns the name as a string slice.

Example

use goud_engine::ecs::components::Name;

let name = Name::new("Player");
assert_eq!(name.as_str(), "Player");

pub fn set(&mut self, name: impl Into<String>)

Sets a new name.

Arguments

• name - The new name string

Example

use goud_engine::ecs::components::Name;

let mut name = Name::new("Player");
name.set("Player_renamed");
assert_eq!(name.as_str(), "Player_renamed");

pub fn len(&self) -> usize

Returns the length of the name in bytes.

Example

use goud_engine::ecs::components::Name;

let name = Name::new("Test");
assert_eq!(name.len(), 4);

pub fn is_empty(&self) -> bool

Returns true if the name is empty.

Example

use goud_engine::ecs::components::Name;

let name = Name::new("");
assert!(name.is_empty());

let name2 = Name::new("Player");
assert!(!name2.is_empty());

pub fn into_string(self) -> String

Consumes the Name and returns the inner String.

Example

use goud_engine::ecs::components::Name;

let name = Name::new("Player");
let string: String = name.into_string();
assert_eq!(string, "Player");

pub fn contains(&self, pattern: &str) -> bool

Returns true if the name contains the given pattern.

Example

use goud_engine::ecs::components::Name;

let name = Name::new("Player_01");
assert!(name.contains("Player"));
assert!(name.contains("01"));
assert!(!name.contains("Enemy"));

pub fn starts_with(&self, prefix: &str) -> bool

Returns true if the name starts with the given prefix.

Example

use goud_engine::ecs::components::Name;

let name = Name::new("Player_01");
assert!(name.starts_with("Player"));
assert!(!name.starts_with("Enemy"));

pub fn ends_with(&self, suffix: &str) -> bool

Returns true if the name ends with the given suffix.

Example

use goud_engine::ecs::components::Name;

let name = Name::new("Player_01");
assert!(name.ends_with("01"));
assert!(!name.ends_with("Player"));

Trait Implementations

impl AsRef<str> for Name

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl Borrow<str> for Name

fn borrow(&self) -> &str

Immutably borrows from an owned value.

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<(), Error>

Formats the value using the given formatter.

impl Default for Name

fn default() -> Name

Returns a Name with an empty string.

impl Display for Name

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

Formats the value using the given formatter.

impl From<&str> for Name

fn from(s: &str) -> Name

Converts to this type from the input type.

impl From<String> for Name

fn from(s: String) -> Name

Converts to this type from the input type.

impl Hash for Name

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

where __H: Hasher,

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 PartialEq<&str> for Name

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

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

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

impl Eq for Name

impl StructuralPartialEq for Name