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.

Example

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

let children = Children::new();
assert!(children.is_empty());

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.

Arguments

• capacity - The number of children to pre-allocate space for

Example

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

let children = Children::with_capacity(100);
assert!(children.is_empty()); // No children yet

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

Creates a Children component from a slice of entities.

Arguments

• children - Slice of child entities

Example

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

let entities = vec![Entity::new(1, 1), Entity::new(2, 1)];
let children = Children::from_slice(&entities);

assert_eq!(children.len(), 2);

pub fn len(&self) -> usize

Returns the number of children.

Example

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

let children = Children::from_slice(&[Entity::new(1, 1), Entity::new(2, 1)]);
assert_eq!(children.len(), 2);

pub fn is_empty(&self) -> bool

Returns true if there are no children.

Example

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

let children = Children::new();
assert!(children.is_empty());

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

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

Arguments

• child - The child entity to add

Example

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

let mut children = Children::new();
children.push(Entity::new(1, 1));
assert_eq!(children.len(), 1);

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

Inserts a child entity at a specific index.

Arguments

• index - The index to insert at
• child - The child entity to insert

Panics

Panics if index > len.

Example

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

let mut children = Children::new();
children.push(Entity::new(1, 1));
children.push(Entity::new(3, 1));
children.insert(1, Entity::new(2, 1)); // Insert at index 1

assert_eq!(children.get(1), Some(Entity::new(2, 1)));

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

Removes and returns the child at the specified index.

Arguments

• index - The index of the child to remove

Returns

The removed child entity.

Panics

Panics if index >= len.

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)]);
let removed = children.remove(0);

assert_eq!(removed, Entity::new(1, 1));
assert_eq!(children.len(), 1);

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

Removes a child entity if it exists, preserving order.

Arguments

• child - The child entity to remove

Returns

true if the child was found and removed, false otherwise.

Performance

This is O(n) as it must search for the child and shift elements.

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)]);

assert!(children.remove_child(Entity::new(1, 1)));
assert!(!children.remove_child(Entity::new(1, 1))); // Already removed

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

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

Arguments

• child - The child entity to remove

Returns

true if the child was found and removed, false otherwise.

Performance

This is O(n) for the search but O(1) for the actual removal. Use this when child order doesn’t matter.

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),
]);

children.swap_remove_child(Entity::new(1, 1));
// Order may have changed, but length is now 2
assert_eq!(children.len(), 2);

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

Returns true if the given entity is a child.

Arguments

• child - The entity to check

Example

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

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

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

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

Returns the child at the given index, if any.

Arguments

• index - The index of the child to get

Returns

Some(entity) if the index is valid, None otherwise.

Example

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

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

assert_eq!(children.get(0), Some(Entity::new(1, 1)));
assert_eq!(children.get(10), None);

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

Returns the first child, if any.

Example

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

let children = Children::from_slice(&[Entity::new(1, 1), Entity::new(2, 1)]);
assert_eq!(children.first(), Some(Entity::new(1, 1)));

let empty = Children::new();
assert_eq!(empty.first(), None);

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

Returns the last child, if any.

Example

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

let children = Children::from_slice(&[Entity::new(1, 1), Entity::new(2, 1)]);
assert_eq!(children.last(), Some(Entity::new(2, 1)));

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

Returns an iterator over the children.

Example

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

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

for child in children.iter() {
    println!("Child: {:?}", child);
}

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

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

Arguments

• child - The entity to find

Returns

Some(index) if found, None otherwise.

Example

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

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

assert_eq!(children.index_of(Entity::new(2, 1)), Some(1));
assert_eq!(children.index_of(Entity::new(99, 1)), None);

pub fn clear(&mut self)

Removes all children.

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)]);
children.clear();

assert!(children.is_empty());

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

Returns the children as a slice.

Example

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

let children = Children::from_slice(&[Entity::new(1, 1), Entity::new(2, 1)]);
let slice = children.as_slice();

assert_eq!(slice.len(), 2);

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

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

Retains only the children that satisfy the predicate.

Arguments

• f - The predicate function

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.

This can be useful for deterministic ordering.

Example

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

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

children.sort_by_index();

assert_eq!(children.get(0), Some(Entity::new(1, 1)));
assert_eq!(children.get(1), Some(Entity::new(2, 1)));
assert_eq!(children.get(2), Some(Entity::new(3, 1)));

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

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

Sorts children using a custom comparison function.

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),
]);

// Sort in reverse order
children.sort_by(|a, b| b.index().cmp(&a.index()));

assert_eq!(children.get(0), Some(Entity::new(3, 1)));

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 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 Component for Children

impl Eq for Children

impl StructuralPartialEq for Children