Taffy

https://docs.rs/taffy/latest
Admin
Taffy is a flexible, high-performance library for UI layout that implements Flexbox, Grid, and Block...
Tokens:1,132,453
Snippets:8,743
Trust Score:9.7
Update:1 week ago
Show doc for...
Tokens:
Raw
### Product example: multiply parsed numbers from vector of strings

Source: https://docs.rs/taffy/latest/taffy/tree/type.TaffyResult.html?search=

Shows how to use the Product implementation for Result. If any element fails to parse, the operation returns an Err. The example demonstrates both success and failure cases.

```rust
let nums = vec!["5", "10", "1", "2"];
let total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();
assert_eq!(total, Ok(100));
let nums = vec!["5", "10", "one", "2"];
let total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();
assert!(total.is_err());
```

--------------------------------

### expect example: panicking on Err

Source: https://docs.rs/taffy/latest/taffy/tree/type.TaffyResult.html?search=

Demonstrates using expect to return the Ok value or panic with a message. The first example shows a panic on Err, and the second shows a recommended message style for environment variables.

```rust
let x: Result<u32, &str> = Err("emergency failure");
x.expect("Testing expect"); // panics with `Testing expect: emergency failure`
```

```rust
let path = std::env::var("IMPORTANT_PATH")
    .expect("env variable `IMPORTANT_PATH` should be set by `wrapper_script.sh`");
```

--------------------------------

### unwrap: Basic usage with Ok and Err

Source: https://docs.rs/taffy/latest/taffy/util/type.ParseResult.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows how to use unwrap on a Result. The first example returns the contained value for Ok. The second example panics when called on an Err.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.unwrap(), 2);
```

```rust
let x: Result<u32, &str> = Err("emergency failure");
x.unwrap(); // panics with `emergency failure`
```

--------------------------------

### Scraped example: public function and its caller

Source: https://docs.rs/taffy/latest/scrape-examples-help.html

Shows a public function in a library crate and an example that calls it. The example is automatically scraped and included in the documentation for the function.

```rust
// src/lib.rs
pub fn a_func() {}
```

```rust
// examples/ex.rs
fn main() {
  a_crate::a_func();
}
```

--------------------------------

### map example

Source: https://docs.rs/taffy/latest/taffy/tree/type.TaffyResult.html?search=

Shows applying a function to the Ok value of a Result, leaving Err untouched. Example prints numbers from a string multiplied by two.

```rust
let line = "1\n2\n3\n4\n";

for num in line.lines() {
    match num.parse::<i32>().map(|i| i * 2) {
        Ok(n) => println!("{n}"),
        Err(..) => {}
    }
}
```

--------------------------------

### measure.rs example using compute_leaf_layout

Source: https://docs.rs/taffy/latest/taffy/fn.compute_leaf_layout.html?search=u32+-%3E+bool

Example from examples/measure.rs (lines 63-70) that uses compute_leaf_layout. Creates a TaffyTree with NodeContext and a FontMetrics struct with char_width and char_height values.

```rust
fn main() -> Result<(), taffy::TaffyError> {
    let mut taffy: TaffyTree<NodeContext> = TaffyTree::new();

    let font_metrics = FontMetrics { char_width: 10.0, char_height: 10.0 };

    let text_node = taffy.new_leaf(font_metrics, |known_dimensions, available_space| {
        // ...
    });
}
```

--------------------------------

### inspect example: logging on Ok

Source: https://docs.rs/taffy/latest/taffy/tree/type.TaffyResult.html?search=

Demonstrates using inspect to call a closure with a reference to the contained value when Ok. The example parses a string, inspects the value, maps it to a power, and expects the result.

```rust
let x: u8 = "4"
    .parse::<u8>()
    .inspect(|x| println!("original: {x}"))
    .map(|x| x.pow(3))
    .expect("literal `4` should parse as a `u8`");
```

--------------------------------

### Example: Result::is_ok

Source: https://docs.rs/taffy/latest/taffy/tree/type.TaffyResult.html?search=

Returns true if the result is Ok.

```rust
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_ok(), true);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_ok(), false);
```

--------------------------------

### Example from examples/custom_tree_vec.rs (line 169)

Source: https://docs.rs/taffy/latest/taffy/compute/fn.compute_flexbox_layout.html

Similar to the previous example, but uses a vector-based tree. The `compute_flexbox_layout` call is made with `tree` instead of `node`, and the node is accessed via `tree.nodes[usize::from(node_id)]`. The same dispatch and out-of-flow handling logic applies.

```rust
163    fn compute_child_layout(&mut self, node_id: NodeId, inputs: taffy::tree::LayoutInput) -> taffy::tree::LayoutOutput {
164        compute_cached_layout(self, node_id, inputs, |tree, node_id, inputs| {
165            let node = &mut tree.nodes[usize::from(node_id)];
166            let font_metrics = FontMetrics { char_width: 10.0, char_height: 10.0 };
167
168            let mut output = match node.kind {
169                NodeKind::Flexbox => compute_flexbox_layout(tree, node_id, inputs),
170                NodeKind::Grid => compute_grid_layout(tree, node_id, inputs),
171                NodeKind::Text => compute_leaf_layout(
172                    inputs,
173                    &node.style,
174                    |_val, _basis| 0.0,
175                    |known_dimensions, available_space| {
176                        text_measure_function(
177                            known_dimensions,
178                            available_space,
179                            node.text_data.as_ref().unwrap(),
180                            &font_metrics,
181                        )
182                    },
183                ),
184                NodeKind::Image => compute_leaf_layout(
185                    inputs,
186                    &node.style,
187                    |_val, _basis| 0.0,
188                    |known_dimensions, _available_space| {
189                        image_measure_function(known_dimensions, node.image_data.as_ref().unwrap())
190                    },
191                ),
192            };
193
194            // Lay out any out-of-flow (absolute/fixed) boxes for which this node is the containing block
195            if inputs.run_mode == taffy::RunMode::PerformLayout {
196                compute_oof_layout(tree, node_id, &mut output);
197            }
198
199            output
200        })
201    }
```

--------------------------------

### Example usage in compute_child_layout (custom_tree_owned_partial.rs)

Source: https://docs.rs/taffy/latest/taffy/compute/fn.compute_oof_layout.html

An example from `examples/custom_tree_owned_partial.rs` (line 190) showing how `compute_oof_layout` is called inside a custom layout implementation. It is invoked after the layout algorithm (flexbox, grid, leaf) and only when `RunMode::PerformLayout` is active, within a `compute_cached_layout` wrapper.

```rust
157    fn compute_child_layout(&mut self, node_id: NodeId, inputs: taffy::tree::LayoutInput) -> taffy::tree::LayoutOutput {
158        compute_cached_layout(self, node_id, inputs, |parent, node_id, inputs| {
159            let node = parent.node_from_id_mut(node_id);
160            let font_metrics = FontMetrics { char_width: 10.0, char_height: 10.0 };
161
162            let mut output = match node.kind {
163                NodeKind::Flexbox => compute_flexbox_layout(node, node_id, inputs),
164                NodeKind::Grid => compute_grid_layout(node, node_id, inputs),
165                NodeKind::Text => compute_leaf_layout(
166                    inputs,
167                    &node.style,
168                    |_val, _basis| 0.0,
169                    |known_dimensions, available_space| {
170                        text_measure_function(
171                            known_dimensions,
172                            available_space,
173                            node.text_data.as_ref().unwrap(),
174                            &font_metrics,
175                        )
176                    },
177                ),
178                NodeKind::Image => compute_leaf_layout(
179                    inputs,
                    &node.style,
180                    |_val, _basis| 0.0,
181                    |known_dimensions, _available_space| {
182                        image_measure_function(known_dimensions, node.image_data.as_ref().unwrap())
183                    },
184                ),
185            };
186
187            // Lay out any out-of-flow (absolute/fixed) boxes for which this node is the containing block
188            if inputs.run_mode == taffy::RunMode::PerformLayout {
189                compute_oof_layout(node, node_id, &mut output);
190            }
191
192            output
193        })
194    }
```

--------------------------------

### as_deref_mut example: mutable dereferencing

Source: https://docs.rs/taffy/latest/taffy/tree/type.TaffyResult.html?search=

Shows how to use as_deref_mut to get a mutable reference to the Ok value. The example mutates the string to uppercase and asserts equality for both Ok and Err cases.

```rust
let mut s = "HELLO".to_string();
let mut x: Result<String, u32> = Ok("hello".to_string());
let y: Result<&mut str, &mut u32> = Ok(&mut s);
assert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), y);

let mut i = 42;
let mut x: Result<String, u32> = Err(42);
let y: Result<&mut str, &mut u32> = Err(&mut i);
assert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), y);
```

--------------------------------

### compute_layout example (examples/flexbox_gap.rs)

Source: https://docs.rs/taffy/latest/taffy/tree/struct.TaffyTree.html?search=

Shows how to use compute_layout with a simple flexbox gap layout. Creates three leaf nodes with fixed size and a root with a gap, then computes layout with Size::MAX_CONTENT and prints the tree.

```rust
6fn main() -> Result<(), taffy::TaffyError> {
7    let mut taffy: TaffyTree<()> = TaffyTree::new();
8
9    let child_style = Style { size: Size { width: length(20.0), height: length(20.0) }, ..Default::default() };
10    let child0 = taffy.new_leaf(child_style.clone())?;
11    let child1 = taffy.new_leaf(child_style.clone())?;
12    let child2 = taffy.new_leaf(child_style.clone())?;
13
14    let root = taffy.new_with_children(
15        Style { gap: Size { width: length(10.0), height: zero() }, ..Default::default() },
16        &[child0, child1, child2],
17    )?;
18
19    // Compute layout and print result
20    taffy.compute_layout(root, Size::MAX_CONTENT)?;
21    taffy.print_tree(root);
22
23    Ok(())
24}
```

--------------------------------

### iter example: iterating over Ok value

Source: https://docs.rs/taffy/latest/taffy/tree/type.TaffyResult.html?search=

Demonstrates using iter to get an iterator over the possibly contained value. The example shows that the iterator yields one value for Ok and none for Err.

```rust
let x: Result<u32, &str> = Ok(7);
assert_eq!(x.iter().next(), Some(&7));

let x: Result<u32, &str> = Err("nothing!");
assert_eq!(x.iter().next(), None);
```

--------------------------------

### ok example

Source: https://docs.rs/taffy/latest/taffy/tree/type.TaffyResult.html?search=

Demonstrates converting a Result to an Option, where Ok becomes Some and Err becomes None.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.ok(), Some(2));

let x: Result<u32, &str> = Err("Nothing here");
assert_eq!(x.ok(), None);
```

--------------------------------

### Cache::get() usage in custom_tree_vec.rs

Source: https://docs.rs/taffy/latest/taffy/tree/struct.Cache.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Example from examples/custom_tree_vec.rs showing how to retrieve a cached result using the get method.

```rust
224    fn cache_get(&mut self, node_id: NodeId, inputs: &taffy::LayoutInput) -> Option<taffy::LayoutOutput> {
225        self.node_from_id_mut(node_id).cache.get(inputs)
226    }
```

--------------------------------

### Example: grid_holy_grail.rs (line 34)

Source: https://docs.rs/taffy/latest/taffy/style_helpers/fn.line.html?search=std%3A%3Avec

Shows how to use `line` to place grid items in a CSS Grid layout. The example sets up a grid with three columns and three rows, then uses `line` and `span` to position header, sidebars, content, and footer. It computes layout and prints the tree.

```rust
19fn main() -> Result<(), taffy::TaffyError> {
20    use taffy::prelude::*;
21
22    let mut taffy: TaffyTree<()> = TaffyTree::new();
23
24    // Setup the grid
25    let root_style = Style {
26        display: Display::Grid,
27        size: Size { width: length(800.0), height: length(600.0) },
28        grid_template_columns: vec![length(250.0), fr(1.0), length(250.0)],
29        grid_template_rows: vec![length(150.0), fr(1.0), length(150.0)],
30        ..default()
31    };
32
33    // Define the child nodes
34    let header = taffy.new_leaf(Style { grid_row: line(1), grid_column: span(3), ..default() })?;
35    let left_sidebar = taffy.new_leaf(Style { grid_row: line(2), grid_column: line(1), ..default() })?;
36    let content_area = taffy.new_leaf(Style { grid_row: line(2), grid_column: line(2), ..default() })?;
37    let right_sidebar = taffy.new_leaf(Style { grid_row: line(2), grid_column: line(3), ..default() })?;
38    let footer = taffy.new_leaf(Style { grid_row: line(3), grid_column: span(3), ..default() })?;
39
40    // Create the container with the children
41    let root = taffy.new_with_children(root_style, &[header, left_sidebar, content_area, right_sidebar, footer])?;
42
43    // Compute layout and print result
44    taffy.compute_layout(root, Size { width: length(800.0), height: length(600.0) })?;
45    taffy.print_tree(root);
46
47    Ok(())
48}
```

--------------------------------

### iter_mut example: mutating Ok value via iterator

Source: https://docs.rs/taffy/latest/taffy/tree/type.TaffyResult.html?search=

Shows how to use iter_mut to get a mutable iterator over the contained value. The example modifies the Ok value and asserts the result, and also shows that Err yields no items.

```rust
let mut x: Result<u32, &str> = Ok(7);
match x.iter_mut().next() {
    Some(v) => *v = 40,
    None => {},
}
assert_eq!(x, Ok(40));

let mut x: Result<u32, &str> = Err("nothing!");
assert_eq!(x.iter_mut().next(), None);
```

--------------------------------

### Basic layout with TaffyTree (examples/basic.rs)

Source: https://docs.rs/taffy/latest/taffy/tree/struct.TaffyTree.html?search=u32+-%3E+bool

Example from examples/basic.rs showing basic usage of TaffyTree: creating leaf and container nodes, computing layout with definite and max-content sizes, then printing layouts.

```rust
fn main() -> Result<(), taffy::TaffyError> {
    let mut taffy: TaffyTree<()> = TaffyTree::new();

    let child = taffy.new_leaf(Style {
        size: Size { width: Dimension::from_percent(0.5), height: Dimension::AUTO },
        ..Default::default()
    })?;

    let node = taffy.new_with_children(
        Style {
            size: Size { width: Dimension::from_length(100.0), height: Dimension::from_length(100.0) },
            justify_content: JustifyContent::CENTER,
            ..Default::default()
        },
        &[child],
    )?;

    println!("Compute layout with 100x100 viewport:");
    taffy.compute_layout(
        node,
        Size { height: AvailableSpace::Definite(100.0), width: AvailableSpace::Definite(100.0) },
    )?;
    println!("node: {:#?}", taffy.layout(node)?);
    println!("child: {:#?}", taffy.layout(child)?);

    println!("Compute layout with undefined (infinite) viewport:");
    taffy.compute_layout(node, Size::MAX_CONTENT)?;
    println!("node: {:#?}", taffy.layout(node)?);
    println!("child: {:#?}", taffy.layout(child)?);

    Ok(())
}

```

--------------------------------

### Cache::get() usage in custom_tree_owned_partial.rs

Source: https://docs.rs/taffy/latest/taffy/tree/struct.Cache.html?search=

Example from examples/custom_tree_owned_partial.rs (line 219) showing how to retrieve a cached result using the get method.

```rust
fn cache_get(&mut self, node_id: NodeId, inputs: &taffy::LayoutInput) -> Option<taffy::LayoutOutput> {
    self.node_from_id_mut(node_id).cache.get(inputs)
}
```

--------------------------------

### expect: Recommended message style for environment variables

Source: https://docs.rs/taffy/latest/taffy/tree/type.TaffyResult.html?search=std%3A%3Avec

Shows the recommended style for expect messages, describing why the Result should be Ok. The example reads an environment variable and expects it to be set.

```rust
let path = std::env::var("IMPORTANT_PATH")
    .expect("env variable `IMPORTANT_PATH` should be set by `wrapper_script.sh`");
```

--------------------------------

### Main function demonstrating custom tree usage

Source: https://docs.rs/taffy/latest/src/custom_tree_owned_partial/custom_tree_owned_partial.rs.html?search=u32+-%3E+bool

Creates a root node, appends a text node and an image node, then computes the layout using Size::MAX_CONTENT.

```rust
fn main() -> Result<(), taffy::TaffyError> {
    let mut root = Node::new_column(Style::DEFAULT);

    let text_node = Node::new_text(
        Style::default(),
        TextContext { text_content: LOREM_IPSUM.into(), writing_mode: WritingMode::Horizontal },
    );
    root.append_child(text_node);

    let image_node = Node::new_image(Style::default(), ImageContext { width: 400.0, height: 300.0 });
    root.append_child(image_node);

    // Compute layout
    root.compute_layout(Size::MAX_CONTENT);

    Ok(())
}
```

--------------------------------

### Cache::get() usage in custom_tree_owned_unsafe.rs

Source: https://docs.rs/taffy/latest/taffy/tree/struct.Cache.html?search=

Example from examples/custom_tree_owned_unsafe.rs (line 217) showing how to retrieve a cached result using the get method with unsafe code.

```rust
fn cache_get(&mut self, node_id: NodeId, inputs: &taffy::LayoutInput) -> Option<taffy::LayoutOutput> {
    unsafe { node_from_id_mut(node_id) }.cache.get(inputs)
}
```

--------------------------------

### Usage in custom_tree_owned_unsafe.rs

Source: https://docs.rs/taffy/latest/taffy/compute/fn.compute_root_layout.html

Example from `examples/custom_tree_owned_unsafe.rs` (line 87) showing a `compute_layout` method that uses an unsafe conversion to get the root node ID and calls `compute_root_layout` with a `StatelessLayoutTree`.

```rust
pub fn compute_layout(&mut self, available_space: Size<AvailableSpace>, use_rounding: bool) {
    let root_node_id = unsafe { self.as_id() };
    compute_root_layout(&mut StatelessLayoutTree, root_node_id, available_space);
    if use_rounding {
        round_layout(&mut StatelessLayoutTree, root_node_id)
    }
}
```

--------------------------------

### compute_layout with definite and infinite viewport (examples/basic.rs)

Source: https://docs.rs/taffy/latest/taffy/tree/struct.TaffyTree.html?search=

Shows how to use compute_layout with both a definite viewport (100x100) and an infinite viewport (Size::MAX_CONTENT). Prints the layout of the node and child after each computation.

```rust
3fn main() -> Result<(), taffy::TaffyError> {
4    let mut taffy: TaffyTree<()> = TaffyTree::new();
5
6    let child = taffy.new_leaf(Style {
7        size: Size { width: Dimension::from_percent(0.5), height: Dimension::AUTO },
8        ..Default::default()
9    })?;
10
11    let node = taffy.new_with_children(
12        Style {
13            size: Size { width: Dimension::from_length(100.0), height: Dimension::from_length(100.0) },
14            justify_content: JustifyContent::CENTER,
15            ..Default::default()
16        },
17        &[child],
18    )?;
19
20    println!("Compute layout with 100x100 viewport:");
21    taffy.compute_layout(
22        node,
23        Size { height: AvailableSpace::Definite(100.0), width: AvailableSpace::Definite(100.0) },
24    )?;
25    println!("node: {:#?}", taffy.layout(node)?);
26    println!("child: {:#?}", taffy.layout(child)?);
27
28    println!("Compute layout with undefined (infinite) viewport:");
29    taffy.compute_layout(node, Size::MAX_CONTENT)?;
30    println!("node: {:#?}", taffy.layout(node)?);
31    println!("child: {:#?}", taffy.layout(child)?);
32
33    Ok(())
34}
```

--------------------------------

### auto_placement_cursor: Get sparse placement cursor for a track

Source: https://docs.rs/taffy/latest/src/taffy/compute/grid/types/cell_occupancy.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Returns the sparse placement cursor for items starting in the given secondary-axis track, or None if the track index is out of bounds.

```rust
pub fn auto_placement_cursor(&self, track_type: AbsoluteAxis, start_at: OriginZeroLine) -> Option<OriginZeroLine> {
    let track_counts = self.track_counts(track_type.other_axis());
    let track_computed_index = track_counts.oz_line_to_next_track(start_at);
    let track_lists = self.track_lists(track_type.other_axis());
    if track_computed_index < 0 || track_computed_index >= track_lists.len() as i16 {
        // Index out of bounds: no tracks to search
        return None;
    }
    track_lists[track_computed_index as usize].auto_placement_cursor
}
```

--------------------------------

### TrackCounts struct definition and methods

Source: https://docs.rs/taffy/latest/src/taffy/compute/grid/types/grid_track_counts.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Defines the TrackCounts struct with fields for negative_implicit, explicit, and positive_implicit track counts. Includes methods to create from raw counts, get total length, and compute implicit grid start and end lines.

```rust
use crate::{compute::grid::OriginZeroLine, geometry::Line};
use core::ops::Range;

/// Stores the number of tracks in a given dimension.
/// Stores separately the number of tracks in the implicit and explicit grids
#[derive(Clone, Copy, Debug, PartialEq, Default)]
pub(crate) struct TrackCounts {
    /// The number of track in the implicit grid before the explicit grid
    pub negative_implicit: u16,
    /// The number of tracks in the explicit grid
    pub explicit: u16,
    /// The number of tracks in the implicit grid after the explicit grid
    pub positive_implicit: u16,
}

impl TrackCounts {
    /// Create a TrackCounts instance from raw track count numbers
    pub const fn from_raw(negative_implicit: u16, explicit: u16, positive_implicit: u16) -> Self {
        Self { negative_implicit, explicit, positive_implicit }
    }

    /// Count the total number of tracks in the axis
    pub const fn len(&self) -> usize {
        (self.negative_implicit + self.explicit + self.positive_implicit) as usize
    }

    /// The OriginZeroLine representing the start of the implicit grid
    pub const fn implicit_start_line(&self) -> OriginZeroLine {
        OriginZeroLine(-(self.negative_implicit as i16))
    }

    /// The OriginZeroLine representing the end of the implicit grid
    pub const fn implicit_end_line(&self) -> OriginZeroLine {
        OriginZeroLine((self.explicit + self.positive_implicit) as i16)
    }
}
```

--------------------------------

### Nested layout with multiple children (examples/nested.rs)

Source: https://docs.rs/taffy/latest/taffy/tree/struct.TaffyTree.html?search=u32+-%3E+bool

Example from examples/nested.rs creating a nested tree with two children per container format, computing layout with definite viewport, and printing all node layouts.

```rust
fn main() -> Result<(), taffy::TaffyError> {
    let mut taffy: TaffyTree<()> = TaffyTree::new();

    // left
    let child_t1 = taffy.new_leaf(Style {
        size: Size { width: Dimension::from_length(5.0), height: Dimension::from_length(5.0) },
        ..Default::default()
    })?;

    let div1 = taffy.new_with_children(
        Style {
            size: Size { width: Dimension::from_percent(0.5), height: Dimension::from_percent(1.0) },
            // justify_content: JustifyContent::Center,
            ..Default::default()
        },
        &[child_t1],
    )?;

    // right
    let child_t2 = taffy.new_leaf(Style {
        size: Size { width: Dimension::from_length(5.0), height: Dimension::from_length(5.0) },
        ..Default::default()
    })?;

    let div2 = taffy.new_with_children(
        Style {
            size: Size { width: Dimension::from_percent(0.5), height: Dimension::from_percent(1.0) },
            // justify_content: JustifyContent::Center,
            ..Default::default()
        },
        &[child_t2],
    )?;

    let container = taffy.new_with_children(
        Style {
            size: Size { width: Dimension::from_percent(1.0), height: Dimension::from_percent(1.0) },
            ..Default::default()
        },
        &[div1, div2],
    )?;

    taffy.compute_layout(
        container,
        Size { height: AvailableSpace::Definite(100.0), width: AvailableSpace::Definite(100.0) },
    )?;

    println!("node: {:#?}", taffy.layout(container)?);

    println!("div1: {:#?}", taffy.layout(div1)?);
    println!("div2: {:#?}", taffy.layout(div2)?);

    println!("child1: {:#?}", taffy.layout(child_t1)?);
    println!("child2: {:#?}", taffy.layout(child_t2)?);

    Ok(())
}

```

--------------------------------

### Grid Layout Algorithm Entry Point

Source: https://docs.rs/taffy/latest/src/taffy/compute/grid/mod.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Public function that runs the grid layout algorithm, resolving the explicit grid, placing items, sizing tracks, and performing alignment and final placement.

```rust
/// Grid layout algorithm
/// This consists of a few phases:
///   - Resolving the explicit grid
///   - Placing items (which also resolves the implicit grid)
///   - Track (row/column) sizing
///   - Alignment & Final item placement
pub fn compute_grid_layout<Tree: LayoutGridContainer>(
    tree: &mut Tree,
    node: NodeId,
    inputs: LayoutInput,
) -> LayoutOutput {
```

--------------------------------

### Example: text_measure_function using AbsoluteAxis

Source: https://docs.rs/taffy/latest/taffy/geometry/enum.AbsoluteAxis.html?search=

Example from examples/common/text.rs (line 32) showing how to use AbsoluteAxis and its other_axis method in a text measurement function.

```rust
pub fn text_measure_function(
    known_dimensions: taffy::geometry::Size<Option<f32>>,
    available_space: taffy::geometry::Size<taffy::style::AvailableSpace>,
    text_context: &TextContext,
    font_metrics: &FontMetrics,
) -> taffy::geometry::Size<f32> {
    use taffy::geometry::AbsoluteAxis;
    use taffy::prelude::*;

    let inline_axis = match text_context.writing_mode {
        WritingMode::Horizontal => AbsoluteAxis::Horizontal,
        WritingMode::Vertical => AbsoluteAxis::Vertical,
    };
    let block_axis = inline_axis.other_axis();
    let words: Vec<&str> = text_context.text_content.split_whitespace().collect();

    if words.is_empty() {
        return Size::ZERO;
    }

    let min_line_length: usize = words.iter().map(|line| line.len()).max().unwrap_or(0);
    let max_line_length: usize = words.iter().map(|line| line.len()).sum();
    let inline_size =
        known_dimensions.get_abs(inline_axis).unwrap_or_else(|| match available_space.get_abs(inline_axis) {
            AvailableSpace::MinContent => min_line_length as f32 * font_metrics.char_width,
            AvailableSpace::MaxContent => max_line_length as f32 * font_metrics.char_width,
            AvailableSpace::Definite(inline_size) => inline_size
                .min(max_line_length as f32 * font_metrics.char_width)
                .max(min_line_length as f32 * font_metrics.char_width),
        });
    let block_size = known_dimensions.get_abs(block_axis).unwrap_or_else(|| {
        let inline_line_length = (inline_size / font_metrics.char_width).floor() as usize;
        let mut line_count = 1;
        let mut current_line_length = 0;
        for word in &words {
            if current_line_length == 0 {
                // first word
                current_line_length = word.len();
            } else if current_line_length + word.len() + 1 > inline_line_length {
                // every word past the first needs to check for line length including the space between words
                // note: a real implementation of this should handle whitespace characters other than ' '
                // and do something more sophisticated for long words
                line_count += 1;
                current_line_length = word.len();
            } else {
                // add the word and a space
                current_line_length += word.len() + 1;
            };
        }
        (line_count as f32) * font_metrics.char_height
    });

    match text_context.writing_mode {
        WritingMode::Horizontal => Size { width: inline_size, height: block_size },
        WritingMode::Vertical => Size { width: block_size, height: inline_size },
    }
}
```

--------------------------------

### custom_tree_owned_partial.rs - Full Example

Source: https://docs.rs/taffy/latest/src/custom_tree_owned_partial/custom_tree_owned_partial.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

This is the complete source code for the custom_tree_owned_partial.rs example. It defines a Node struct with directly owned children, implements the TraversePartialTree and LayoutPartialTree traits, and uses the low-level compute APIs. The example is limited to implementing TraversePartialTree because an iterator created from a node can't access grandchildren.

```rust
1//! ## Example: Partial Tree with Directly Owned Children
2//!
3//! The following example demonstrate an implementation of Taffy's Partial trait and usage of the low-level compute APIs.
4//! This example uses directly owned children with NodeId's being index's into vec on parent node.
5//! Since an iterator created from a node can't access grandchildren, we are limited to only implement `TraversePartialTree`.
6//! See the [`crate::tree::traits`] module for more details about the low-level traits.
7
8mod common {
9    pub mod image;
10    pub mod text;
11}
12use common::image::{image_measure_function, ImageContext};
13use common::text::{text_measure_function, FontMetrics, TextContext, WritingMode, LOREM_IPSUM};
14use taffy::{
15    compute_cached_layout, compute_flexbox_layout, compute_grid_layout, compute_leaf_layout, compute_oof_layout,
16    compute_root_layout, prelude::*, Cache, CacheTree, Layout, Style,
17};
18
19#[derive(Debug, Copy, Clone)]
20#[allow(dead_code)]
21enum NodeKind {
22    Flexbox,
23    Grid,
24    Text,
25    Image,
26}
27
28struct Node {
29    kind: NodeKind,
30    style: Style,
31    text_data: Option<TextContext>,
32    image_data: Option<ImageContext>,
33    cache: Cache,
34    layout: Layout,
35    children: Vec<Node>,
36    hoisted_children: Vec<NodeId>,
37}
38
39impl Default for Node {
40    fn default() -> Self {
41        Node {
42            kind: NodeKind::Flexbox,
43            style: Style::default(),
44            text_data: None,
45            image_data: None,
46            cache: Cache::new(),
47            layout: Layout::with_order(0),
48            children: Vec::new(),
49            hoisted_children: Vec::new(),
50        }
51    }
52}
53
54#[allow(dead_code)]
55impl Node {
56    pub fn new_row(style: Style) -> Node {
57        Node {
58            kind: NodeKind::Flexbox,
59            style: Style { display: Display::Flex, flex_direction: FlexDirection::Row, ..style },
60            ..Node::default()
61        }
62    }
63    pub fn new_column(style: Style) -> Node {
64        Node {
65            kind: NodeKind::Flexbox,
66            style: Style { display: Display::Flex, flex_direction: FlexDirection::Column, ..style },
67            ..Node::default()
68        }
69    }
70    pub fn new_grid(style: Style) -> Node {
71        Node { kind: NodeKind::Grid, style: Style { display: Display::Grid, ..style }, ..Node::default() }
72    }
73    pub fn new_text(style: Style, text_data: TextContext) -> Node {
74        Node { kind: NodeKind::Text, style, text_data: Some(text_data), ..Node::default() }
75    }
76    pub fn new_image(style: Style, image_data: ImageContext) -> Node {
77        Node { kind: NodeKind::Image, style, image_data: Some(image_data), ..Node::default() }
78    }
79    pub fn append_child(&mut self, node: Node) {
80        self.children.push(node);
81    }
82
83    pub fn compute_layout(&mut self, available_space: Size<AvailableSpace>) {
84        compute_root_layout(self, NodeId::from(usize::MAX), available_space);
85    }
86
87    /// The methods on LayoutPartialTree need to be able to access:
88    ///
89    ///  - The node being laid out
90    ///  - Direct children of the node being laid out
91    ///
    /// Each must have an ID. For children we simply use it's index. For the node itself
    /// we use usize::MAX on the assumption that there will never be that many children.
92    fn node_from_id(&self, node_id: NodeId) -> &Node {
93        let idx = usize::from(node_id);
94        if idx == usize::MAX {
95            self
96        } else {
97            &self.children[idx]
98        }
99    }
100
101    fn node_from_id_mut(&mut self, node_id: NodeId) -> &mut Node {
102        let idx = usize::from(node_id);
103        if idx == usize::MAX {
104            self
105        } else {
106            &mut self.children[idx]
107        }
108    }
109}
110
111struct ChildIter(std::ops::Range<usize>);
112impl Iterator for ChildIter {
113    type Item = NodeId;
114    fn next(&mut self) -> Option<Self::Item> {
115        self.0.next().map(NodeId::from)
116    }
117}
118
119impl taffy::TraversePartialTree for Node {
120    type ChildIter<'a> = ChildIter;
121
122    fn child_ids(&self, _node_id: NodeId) -> Self::ChildIter<'_> {
123        ChildIter(0..self.children.len())
124    }
125
126    fn child_count(&self, _node_id: NodeId) -> usize {
127        self.children.len()
128    }
129
130    fn get_child_id(&self, _node_id: NodeId, index: usize) -> NodeId {
131        NodeId::from(index)
132    }
133}
134
135impl taffy::LayoutPartialTree for Node {
136    type CoreContainerStyle<'a>
137        = &'a Style
138    where
139        Self: 'a;
140
141    type CustomIdent = String;
142
143    fn get_core_container_style(&self, node_id: NodeId) -> Self::CoreContainerStyle<'_> {
144        // ... (rest of the implementation)
145    }
146}
```

--------------------------------

### as_ref example

Source: https://docs.rs/taffy/latest/taffy/tree/type.TaffyResult.html?search=

Shows converting a Result to a Result of references, leaving the original in place.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.as_ref(), Ok(&2));

let x: Result<u32, &str> = Err("Error");
assert_eq!(x.as_ref(), Err(&"Error"));
```

--------------------------------

### compute_preliminary function implementation with flex layout algorithm steps

Source: https://docs.rs/taffy/latest/src/taffy/compute/flexbox.rs.html?search=u32+-%3E+bool

This snippet shows the compute_preliminary function, which implements the initial steps of the flex layout algorithm. It computes constants, generates anonymous flex items, determines available space, computes flex base sizes, collects flex lines, and determines the container's main size. It includes debug logging and conditional compilation for the 'flexbox_balance' feature.

```rust
/// Compute a preliminary size for an item
fn compute_preliminary(tree: &mut impl LayoutFlexboxContainer, node: NodeId, inputs: LayoutInput) -> LayoutOutput {
    let LayoutInput { known_dimensions, parent_size, available_space, run_mode, .. } = inputs;

    // Define some general constants we will need for the remainder of the algorithm.
    let mut constants = compute_constants(
        tree,
        tree.get_flexbox_container_style(node),
        known_dimensions,
        inputs.known_dimensions_are_definite,
        parent_size,
        available_space,
    );

    // 9. Flex Layout Algorithm

    // 9.1. Initial Setup

    // 1. Generate anonymous flex items as described in §4 Flex Items.
    debug_log!("generate_anonymous_flex_items");
    let mut flex_items = generate_anonymous_flex_items(tree, node, &constants);

    // 9.2. Line Length Determination

    // 2. Determine the available main and cross space for the flex items
    debug_log!("determine_available_space");
    let available_space = determine_available_space(known_dimensions, available_space, &constants);

    // 3. Determine the flex base size and hypothetical main size of each item.
    debug_log!("determine_flex_base_size");
    determine_flex_base_size(tree, &constants, available_space, &mut flex_items);

    #[cfg(feature = "debug")]
    for item in flex_items.iter() {
        debug_log!("item.flex_basis", item.flex_basis);
        debug_log!("item.inner_flex_basis", item.inner_flex_basis);
        debug_log!("item.hypothetical_outer_size", dbg:item.hypothetical_outer_size);
        debug_log!("item.hypothetical_inner_size", dbg:item.hypothetical_inner_size);
        debug_log!("item.resolved_minimum_main_size", dbg:item.resolved_minimum_main_size);
    }

    // 4. Determine the main size of the flex container
    // This has already been done as part of compute_constants. The inner size is exposed as constants.node_inner_size.

    // 9.3. Main Size Determination

    // 5. Collect flex items into flex lines.
    debug_log!("collect_flex_lines");
    #[cfg(feature = "flexbox_balance")]
    let mut flex_lines = if constants.is_balance {
        collect_balanced_flex_lines(&constants, available_space, &mut flex_items)
    } else {
        collect_flex_lines(&constants, available_space, &mut flex_items)
    };
    #[cfg(not(feature = "flexbox_balance"))]
    let mut flex_lines = collect_flex_lines(&constants, available_space, &mut flex_items);

    // If container size is undefined, determine the container's main size
    // and then re-resolve gaps based on newly determined size
    debug_log!("determine_container_main_size");
    if let Some(inner_main_size) = constants.node_inner_size.main(constants.dir) {
        let outer_main_size = inner_main_size + constants.content_box_inset.main_axis_sum(constants.dir);
        constants.inner_container_size.set_main(constants.dir, inner_main_size);
        constants.container_size.set_main(constants.dir, outer_main_size);
    } else {
        // Sets constants.container_size and constants.outer_container_size
        determine_container_main_size(tree, available_space, &mut flex_lines, &mut constants);
        constants.node_inner_size.set_main(constants.dir, Some(constants.inner_container_size.main(constants.dir)));
        constants.node_outer_size.set_main(constants.dir, Some(constants.container_size.main(constants.dir)));

        debug_log!("constants.node_outer_size", dbg:constants.node_outer_size);
        debug_log!("constants.node_inner_size", dbg:constants.node_inner_size);

        // Re-resolve percentage gaps
        let style = tree.get_flexbox_container_style(node);
        let inner_container_size = constants.inner_container_size.main(constants.dir);
        let new_gap = style
            .gap()
            .main(constants.dir)
            .maybe_resolve(inner_container_size, |val, basis| tree.calc(val, basis))
            .unwrap_or(0.0);
        constants.gap.set_main(constants.dir, new_gap);
    }

    // If only the container's main size has been requested then we are done, as nothing below changes it. This
    // avoids measuring the cross size of every item.
    if run_mode == RunMode::ComputeSize {
        let main_axis_is_requested_axis = match inputs.axis {
```

--------------------------------

### Main function building and printing a layout tree

Source: https://docs.rs/taffy/latest/src/custom_tree_owned_unsafe/custom_tree_owned_unsafe.rs.html?search=

Creates a root column node, appends text and image nodes, computes layout with maximum content size, and prints the tree.

```rust
fn main() -> Result<(), taffy::TaffyError> {
    let mut root = Node::new_column(Style::DEFAULT);

    let text_node = Node::new_text(
        Style::default(),
        TextContext { text_content: LOREM_IPSUM.into(), writing_mode: WritingMode::Horizontal },
    );
    root.append_child(text_node);

    let image_node = Node::new_image(Style::default(), ImageContext { width: 400.0, height: 300.0 });
    root.append_child(image_node);

    // Compute layout and print result
    root.compute_layout(Size::MAX_CONTENT, true);
    root.print_tree();

    Ok(())
}
```

--------------------------------

### FromIterator example: collect with checked_sub

Source: https://docs.rs/taffy/latest/taffy/tree/type.TaffyResult.html?search=

Shows how to collect an iterator of `Result` values into a `Result<Vec<_>, _>`, stopping at the first `Err`. This example subtracts one and checks for underflow.

```rust
let v = vec![1, 2, 0];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|
    x.checked_sub(1).ok_or("Underflow!")
).collect();
assert_eq!(res, Err("Underflow!"));
```

--------------------------------

### Grid holy grail layout with TaffyTree (examples/grid_holy_grail.rs)

Source: https://docs.rs/taffy/latest/taffy/struct.TaffyTree.html

Creates a TaffyTree and builds a grid layout with header, sidebars, content, and footer. Uses grid template columns/rows and spans, then computes layout and prints the tree.

```rust
fn main() -> Result<(), taffy::TaffyError> {
    use taffy::prelude::*;

    let mut taffy: TaffyTree<()> = TaffyTree::new();

    // Setup the grid
    let root_style = Style {
        display: Display::Grid,
        size: Size { width: length(800.0), height: length(600.0) },
        grid_template_columns: vec![length(250.0), fr(1.0), length(250.0)],
        grid_template_rows: vec![length(150.0), fr(1.0), length(150.0)],
        ..default()
    };

    // Define the child nodes
    let header = taffy.new_leaf(Style { grid_row: line(1), grid_column: span(3), ..default() })?;
    let left_sidebar = taffy.new_leaf(Style { grid_row: line(2), grid_column: line(1), ..default() })?;
    let content_area = taffy.new_leaf(Style { grid_row: line(2), grid_column: line(2), ..default() })?;
    let right_sidebar = taffy.new_leaf(Style { grid_row: line(2), grid_column: line(3), ..default() })?;
    let footer = taffy.new_leaf(Style { grid_row: line(3), grid_column: span(3), ..default() })?;

    // Create the container with the children
    let root = taffy.new_with_children(root_style, &[header, left_sidebar, content_area, right_sidebar, footer])?;

    // Compute layout and print result
    taffy.compute_layout(root, Size { width: length(800.0), height: length(600.0) })?;
    taffy.print_tree(root);

    Ok(())
}
```

--------------------------------

### FromIterator example: collect with checked_add

Source: https://docs.rs/taffy/latest/taffy/tree/type.TaffyResult.html?search=

Shows how to collect an iterator of `Result` values into a `Result<Vec<_>, _>`, stopping at the first `Err`. This example increments integers and checks for overflow.

```rust
let v = vec![1, 2];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|
    x.checked_add(1).ok_or("Overflow!")
).collect();
assert_eq!(res, Ok(vec![2, 3]));
```

--------------------------------

### is_out_of_flow example from custom_tree_owned_unsafe.rs

Source: https://docs.rs/taffy/latest/taffy/style/enum.Position.html

Example implementation of the is_out_of_flow method for a custom tree using unsafe pointer access. It calls the style's position is_out_of_flow method.

```rust
fn is_out_of_flow(&self, node_id: NodeId) -> bool {
    unsafe { node_from_id(node_id).style.position.is_out_of_flow() }
}
```

--------------------------------

### is_out_of_flow example from custom_tree_vec.rs

Source: https://docs.rs/taffy/latest/taffy/style/enum.Position.html

Example implementation of the is_out_of_flow method for a custom tree using a vector-based node storage. It calls the style's position is_out_of_flow method.

```rust
fn is_out_of_flow(&self, node_id: NodeId) -> bool {
    self.node_from_id(node_id).style.position.is_out_of_flow()
}
```
Tokens:
Raw