Struct Children 

pub struct Children { /* private fields */ }

Component containing a list of child entities.

This component stores references to all immediate children of an entity. The order of children is preserved and can be significant for rendering order or other order-dependent operations.

Capacity and Performance

Internally uses a Vec<Entity>, so:

• Adding children is O(1) amortized
• Removing children is O(n) where n is the number of children
• Iteration is cache-friendly

For entities with many children, consider using with_capacity to pre-allocate memory.

Example

use goud_engine::ecs::Entity;
use goud_engine::ecs::components::Children;

let mut children = Children::new();

let child1 = Entity::new(1, 1);
let child2 = Entity::new(2, 1);

children.push(child1);
children.push(child2);

assert_eq!(children.len(), 2);
assert!(children.contains(child1));

Implementations

impl Children

pub fn new() -> Children

Creates an empty Children component.

pub fn with_capacity(capacity: usize) -> Children

Creates a Children component with pre-allocated capacity.

Use this when you know approximately how many children the entity will have.

pub fn from_slice(children: &[Entity]) -> Children

Creates a Children component from a slice of entities.

pub fn len(&self) -> usize

Returns the number of children.

pub fn is_empty(&self) -> bool

Returns true if there are no children.

pub fn push(&mut self, child: Entity)

Adds a child entity to the end of the children list.

pub fn insert(&mut self, index: usize, child: Entity)

Inserts a child entity at a specific index.

Panics

Panics if index > len.

pub fn remove(&mut self, index: usize) -> Entity

Removes and returns the child at the specified index.

Panics

Panics if index >= len.

pub fn remove_child(&mut self, child: Entity) -> bool

Removes a child entity if it exists, preserving order.

Returns true if the child was found and removed, false otherwise. This is O(n) as it must search for the child and shift elements.

pub fn swap_remove_child(&mut self, child: Entity) -> bool

Removes a child entity using swap-remove (faster but doesn’t preserve order).

Returns true if the child was found and removed, false otherwise. O(n) for the search but O(1) for the actual removal.

pub fn contains(&self, child: Entity) -> bool

Returns true if the given entity is a child.

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

Returns the child at the given index, if any.

pub fn first(&self) -> Option<Entity>

Returns the first child, if any.

pub fn last(&self) -> Option<Entity>

Returns the last child, if any.

pub fn iter(&self) -> impl Iterator<Item = &Entity>

Returns an iterator over the children.

pub fn index_of(&self, child: Entity) -> Option<usize>

Returns the index of a child entity, if it exists.

Returns Some(index) if found, None otherwise.

pub fn clear(&mut self)

Removes all children.

pub fn as_slice(&self) -> &[Entity]

Returns the children as a slice.

pub fn retain<F>(&mut self, f: F)

where F: FnMut(&Entity) -> bool,

Retains only the children that satisfy the predicate.

Example

use goud_engine::ecs::Entity;
use goud_engine::ecs::components::Children;

let mut children = Children::from_slice(&[
    Entity::new(1, 1),
    Entity::new(2, 1),
    Entity::new(3, 1),
]);

// Keep only entities with even indices
children.retain(|e| e.index() % 2 == 0);

assert_eq!(children.len(), 1);
assert!(children.contains(Entity::new(2, 1)));

pub fn sort_by_index(&mut self)

Sorts children by their entity index for deterministic ordering.

pub fn sort_by<F>(&mut self, compare: F)

where F: FnMut(&Entity, &Entity) -> Ordering,

Sorts children using a custom comparison function.

Trait Implementations

impl Clone for Children

fn clone(&self) -> Children

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Children

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

Formats the value using the given formatter.

impl Default for Children

fn default() -> Children

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Children

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Children

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

Formats the value using the given formatter.

impl From<&[Entity]> for Children

fn from(children: &[Entity]) -> Children

Converts to this type from the input type.

impl From<Children> for Vec<Entity>

fn from(children: Children) -> Vec<Entity>

Converts to this type from the input type.

impl From<Vec<Entity>> for Children

fn from(children: Vec<Entity>) -> Children

Converts to this type from the input type.

impl<'a> IntoIterator for &'a Children

type Item = &'a Entity

The type of the elements being iterated over.

type IntoIter = Iter<'a, Entity>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a Children as IntoIterator>::IntoIter

Creates an iterator from a value.

impl IntoIterator for Children

type Item = Entity

The type of the elements being iterated over.

type IntoIter = IntoIter<Entity>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Children as IntoIterator>::IntoIter

Creates an iterator from a value.

impl PartialEq for Children

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Component for Children

impl Eq for Children

impl StructuralPartialEq for Children