Renderdag 0.3.0

https://docs.rs/renderdag/0.3.0/renderdag/
Admin
Renderdag is a Rust crate that provides components for rendering directed acyclic graphs, including...
Tokens:31,644
Snippets:330
Trust Score:9.1
Update:4 months ago
Show doc for...
Tokens:
Raw
### Example: Convert char to String

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Demonstrates creating a `String` from a single `char`.

```Rust
let c: char = 'a';
let s: String = String::from(c);
assert_eq!("a", &s[..])
```

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

### Example: Convert Box<str> to String

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Demonstrates converting a `String` to `Box<str>` and then back to `String`.

```Rust
let s1: String = String::from("hello world");
let s2: Box<str> = s1.into_boxed_str();
let s3: String = String::from(s2);

assert_eq!("hello world", s3)
```

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

### Try From Vec<u8> to String Example

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Demonstrates converting a Vec<u8> into a String, asserting successful conversion.

```Rust
let s1 = b"hello world".to_vec();
let v1 = String::try_from(s1).unwrap();
assert_eq!(v1, "hello world");

```

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

### Example: Convert Cow<'a, str> to String

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Shows converting a borrowed `Cow<'_, str>` into an owned `String`, which involves allocation and copying.

```Rust
// If the string is not owned...
let cow: Cow<'_, str> = Cow::Borrowed("eggplant");
// It will allocate on the heap and copy the string.
let owned: String = String::from(cow);
assert_eq!(&owned[..], "eggplant")
```

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

### Rust String reserve() with existing capacity

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Calling `reserve` when sufficient capacity already exists may not increase the capacity. This example shows that after reserving, subsequent calls with a smaller additional amount do not change the capacity.

```rust
let mut s = String::with_capacity(10);
s.push('a');
s.push('b');

// s now has a length of 2 and a capacity of at least 10
let capacity = s.capacity();
assert_eq!(2, s.len());
assert!(capacity >= 10);

// Since we already have at least an extra 8 capacity, calling this...
s.reserve(8);

// ... doesn't actually increase.
assert_eq!(capacity, s.capacity());
```

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

### Rust String try_reserve_exact() example

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Use `try_reserve_exact` to attempt reserving the minimum capacity, returning a `Result`. It avoids deliberate over-allocation but notes that the allocator might still provide more space. Prefer `try_reserve` if future insertions are expected.

```rust
use std::collections::TryReserveError;

fn process_data(data: &str) -> Result<String, TryReserveError> {
    let mut output = String::new();

    // Pre-reserve the memory, exiting if we can't
    output.try_reserve_exact(data.len())?;

    // Now we know this can't OOM in the middle of our complex work
    output.push_str(data);

    Ok(output)
}
```

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

### Rust String try_reserve() example

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Use `try_reserve` to attempt reserving capacity, returning a `Result`. This is useful for operations where allocation failure should be handled gracefully. The function preserves contents even if an error occurs.

```rust
use std::collections::TryReserveError;

fn process_data(data: &str) -> Result<String, TryReserveError> {
    let mut output = String::new();

    // Pre-reserve the memory, exiting if we can't
    output.try_reserve(data.len())?;

    // Now we know this can't OOM in the middle of our complex work
    output.push_str(data);

    Ok(output)
}
```

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

### Rust String reserve_exact() with existing capacity

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Calling `reserve_exact` when sufficient capacity already exists may not increase the capacity. This example demonstrates that subsequent calls with a smaller additional amount do not change the capacity.

```rust
let mut s = String::with_capacity(10);
s.push('a');
s.push('b');

// s now has a length of 2 and a capacity of at least 10
let capacity = s.capacity();
assert_eq!(2, s.len());
assert!(capacity >= 10);

// Since we already have at least an extra 8 capacity, calling this...
s.reserve_exact(8);

// ... doesn't actually increase.
assert_eq!(capacity, s.capacity());
```

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

### Any Trait Implementation

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/struct.RenderConfig.html

Gets the TypeId of the RenderConfig instance.

```rust
fn type_id(&self) -> TypeId
```

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

### Get String as a byte slice

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Returns a byte slice of the String's contents. The inverse of this method is from_utf8.

```Rust
let s = String::from("hello");

assert_eq!(&[104, 101, 108, 108, 111], s.as_bytes());
```

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

### Rust String shrink_to_fit() example

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Use `shrink_to_fit` to reduce the String's capacity to match its current length. This is useful for freeing up memory when the String will not grow further.

```rust
let mut s = String::from("foo");

s.reserve(100);
assert!(s.capacity() >= 100);

s.shrink_to_fit();
assert_eq!(3, s.capacity());
```

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

### Get String Capacity

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Returns the current capacity of the String in bytes. This is the amount of space allocated for the string's contents.

```rust
let s = String::from("hello");
let capacity = s.capacity();
// The capacity will be at least 5 bytes, but could be more.
```

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

### Handle invalid UTF-16LE bytes conversion to String (nightly)

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

An experimental nightly-only API to decode a UTF-16 Little Endian encoded byte slice. This example shows how to handle errors resulting from invalid UTF-16LE data.

```rust
#![feature(str_from_utf16_endian)]
// 𝄞mu<invalid>ic
let v = &[0x34, 0xD8, 0x1E, 0xDD, 0x6d, 0x00, 0x75, 0x00,
          0x00, 0xD8, 0x69, 0x00, 0x63, 0x00];
assert!(String::from_utf16le(v).is_err());
```

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

### Handle invalid UTF-16BE bytes conversion to String (nightly)

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

An experimental nightly-only API to decode a UTF-16 Big Endian encoded byte slice. This example shows how to handle errors resulting from invalid UTF-16BE data.

```rust
#![feature(str_from_utf16_endian)]
// 𝄞mu<invalid>ic
let v = &[0xD8, 0x34, 0xDD, 0x1E, 0x00, 0x6d, 0x00, 0x75,
          0xD8, 0x00, 0x00, 0x69, 0x00, 0x63];
assert!(String::from_utf16be(v).is_err());
```

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

### Get String Slice Reference

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Extracts an immutable string slice (&str) that references the entire content of the String.

```rust
let s = String::from("foo");

assert_eq!("foo", s.as_str());
```

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

### GraphLayout::new

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/struct.GraphLayout.html

Creates a new instance of GraphLayout. This is a constructor for the GraphLayout struct.

```APIDOC
## GraphLayout::new

### Description
Creates a new instance of `GraphLayout`.

### Method
`new()`

### Returns
- `Self`: A new `GraphLayout` instance.
```

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

### GraphLayout::new Constructor

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/struct.GraphLayout.html

Creates a new instance of GraphLayout. This is the primary way to initialize the struct.

```rust
pub fn new() -> Self>
```

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

### Default for String

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Provides a way to create an empty String.

```APIDOC
## Default for String

### fn default() -> String

Creates an empty `String`.
```

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

### Get String Length in Bytes

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Returns the length of the string in bytes. Note that this may differ from the number of characters or graphemes.

```Rust
let a = String::from("foo");
assert_eq!(a.len(), 3);

let fancy_f = String::from("ƒoo");
assert_eq!(fancy_f.len(), 4);
assert_eq!(fancy_f.chars().count(), 3);
```

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

### Create String from Raw Parts

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Demonstrates creating a String from a raw pointer, length, and capacity. This is an unsafe operation and requires careful management of memory and UTF-8 invariants.

```rust
unsafe {
    let s = String::from("hello");

    // Deconstruct the String into parts.
    let (ptr, len, capacity) = s.into_raw_parts();

    let s = String::from_raw_parts(ptr, len, capacity);

    assert_eq!(String::from("hello"), s);
}
```

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

### Get Mutable String Slice Reference

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Converts a String into a mutable string slice (&mut str), allowing in-place modifications.

```rust
let mut s = String::from("foobar");
let s_mut_str = s.as_mut_str();

s_mut_str.make_ascii_uppercase();

assert_eq!("FOOBAR", s_mut_str);
```

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

### pub fn try_reserve_exact( &mut self, additional: usize, ) -> Result<(), TryReserveError>

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Tries to reserve the minimum capacity for at least `additional` bytes more than the current length. Unlike `try_reserve`, this will not deliberately over-allocate to speculatively avoid frequent allocations. After calling `try_reserve_exact`, capacity will be greater than or equal to `self.len() + additional` if it returns `Ok(())`. Does nothing if the capacity is already sufficient.

```APIDOC
## pub fn try_reserve_exact( &mut self, additional: usize, ) -> Result<(), TryReserveError>

### Description
Tries to reserve the minimum capacity for at least `additional` bytes more than the current length. Unlike `try_reserve`, this will not deliberately over-allocate to speculatively avoid frequent allocations. After calling `try_reserve_exact`, capacity will be greater than or equal to `self.len() + additional` if it returns `Ok(())`. Does nothing if the capacity is already sufficient.
Note that the allocator may give the collection more space than it requests. Therefore, capacity can not be relied upon to be precisely minimal. Prefer `try_reserve` if future insertions are expected.

### Errors
If the capacity overflows, or the allocator reports a failure, then an error is returned.

### Examples
```rust
use std::collections::TryReserveError;

fn process_data(data: &str) -> Result<String, TryReserveError> {
    let mut output = String::new();

    // Pre-reserve the memory, exiting if we can't
    output.try_reserve_exact(data.len())?;

    // Now we know this can't OOM in the middle of our complex work
    output.push_str(data);

    Ok(output)
}
```
```

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

### Create String with Try-With-Capacity (Nightly)

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

An experimental nightly-only API to create a new empty String with at least the specified capacity. Returns an error if capacity exceeds isize::MAX or if memory allocation fails.

```rust
pub fn try_with_capacity(capacity: usize) -> Result<String, TryReserveError>
```

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

### Clone Implementation for StepDetails

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/struct.StepDetails.html

Provides the ability to create a duplicate of a StepDetails instance. This is useful for scenarios where a copy of the step's configuration is needed.

```rust
impl<'a, T: Clone> Clone for StepDetails<'a, T>
fn clone(&self) -> StepDetails<'a, T>
```

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

### GraphRenderer::new Constructor

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/struct.GraphRenderer.html

Creates a new instance of GraphRenderer. Requires a RenderConfig object.

```rust
pub fn new(config: RenderConfig) -> Self>
```

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

### from_raw_parts

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Creates a new `String` from a pointer, a length, and a capacity. This is an unsafe operation and requires careful management of memory.

```APIDOC
## from_raw_parts

### Description
Creates a new `String` from a pointer, a length, and a capacity. This function is unsafe and requires that the provided components are valid and correctly managed.

### Method
`unsafe fn from_raw_parts(buf: *mut u8, length: usize, capacity: usize) -> String`

### Parameters
- `buf` (*mut u8): A raw pointer to the buffer.
- `length` (usize): The length of the string in bytes.
- `capacity` (usize): The allocated capacity of the buffer in bytes.

### Safety
- All safety requirements for `Vec::<u8>::from_raw_parts` must be met.
- All safety requirements for `String::from_utf8_unchecked` must be met.
- The caller must ensure that `buf` points to valid memory that can be managed by `String`.

### Examples
```rust
unsafe {
    let s = String::from("hello");
    let (ptr, len, cap) = s.into_raw_parts();
    let rebuilt = String::from_raw_parts(ptr, len, cap);
    assert_eq!(rebuilt, "hello");
}
```
```

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

### Handle invalid UTF-16 slice conversion to String

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Attempts to decode a native endian UTF-16 encoded slice into a String. This example demonstrates how to check for and handle errors when invalid UTF-16 data is present.

```rust
// 𝄞mu<invalid>ic
let v = &[0xD834, 0xDD1E, 0x006d, 0x0075,
          0xD800, 0x0069, 0x0063];
assert!(String::from_utf16(v).is_err());
```

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

### CloneToUninit Trait Implementation (Nightly)

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/struct.RenderConfig.html

Nightly-only experimental API for copy-assignment to uninitialized memory.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

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

### Create String with Capacity

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Creates an empty String with a specified initial buffer capacity to minimize reallocations when appending data. If capacity is 0, it's identical to `new()`.

```rust
let mut s = String::with_capacity(10);

// The String contains no chars, even though it has capacity for more
assert_eq!(s.len(), 0);

// These are all done without reallocating...
let cap = s.capacity();
for _ in 0..10 {
    s.push('a');
}

assert_eq!(s.capacity(), cap);

// ...but this may make the string reallocate
s.push('a');
```

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

### from(c: char) -> String

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Allocates an owned `String` from a single character.

```APIDOC
## fn from(c: char) -> String

### Description
Allocates an owned `String` from a single character.

### Parameters
#### Path Parameters
- **c** (char) - Required - The character to convert into a String.

### Request Example
```json
{
  "example": "let c: char = 'a';\nlet s: String = String::from(c);\nassert_eq!(\"a\", &s[..]);"
}
```
```

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

### String Comparison: Partial Ordering

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Provides partial ordering comparison for String values. Returns an Option<Ordering>.

```Rust
fn partial_cmp(&self, other: &String) -> Option<Ordering>
```

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

### from(s: Cow<'a, str>) -> String

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Converts a clone-on-write string `Cow<'a, str>` to an owned `String`. This extracts the owned string, cloning if necessary.

```APIDOC
## fn from(s: Cow<'a, str>) -> String

### Description
Converts a clone-on-write string to an owned instance of `String`. This extracts the owned string, clones the string if it is not already owned.

### Parameters
#### Path Parameters
- **s** (Cow<'a, str>) - Required - The clone-on-write string to convert.

### Request Example
```json
{
  "example": "// If the string is not owned...\nlet cow: Cow<'_, str> = Cow::Borrowed(\"eggplant\");\n// It will allocate on the heap and copy the string.\nlet owned: String = String::from(cow);\nassert_eq!(&owned[..], \"eggplant\");"
}
```
```

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

### Rust String shrink_to() example

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Use `shrink_to` to reduce the String's capacity to a minimum specified value, ensuring it remains at least as large as the length and the supplied `min_capacity`. If current capacity is less than the limit, it's a no-op.

```rust
let mut s = String::from("foo");

s.reserve(100);
assert!(s.capacity() >= 100);

s.shrink_to(10);
assert!(s.capacity() >= 10);
s.shrink_to(0);
assert!(s.capacity() >= 3);
```

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

### from(s: &String) -> String

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Converts a `&String` into an owned `String` by cloning the input string.

```APIDOC
## fn from(s: &String) -> String

### Description
Converts a `&String` into an owned `String`. This clones `s` and returns the clone.

### Parameters
#### Path Parameters
- **s** (&String) - Required - A reference to the string to convert.
```

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

### pub fn shrink_to_fit(&mut self)

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Shrinks the capacity of this `String` to match its length.

```APIDOC
## pub fn shrink_to_fit(&mut self)

### Description
Shrinks the capacity of this `String` to match its length.

### Examples
```rust
let mut s = String::from("foo");

s.reserve(100);
assert!(s.capacity() >= 100);

s.shrink_to_fit();
assert_eq!(3, s.capacity());
```
```

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

### Clone Implementation for GraphRenderer

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/struct.GraphRenderer.html

Provides methods for cloning GraphRenderer instances. `clone` creates a new instance, while `clone_from` performs copy-assignment.

```rust
fn clone(&self) -> GraphRenderer>
```

```rust
fn clone_from(&mut self, source: &Self)>
```

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

### GraphLayout::layout_with_steps Method

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/struct.GraphLayout.html

Computes the layout steps for a slice of graph nodes and applies a closure for each computed step detail. Requires nodes to implement the GraphNode trait and Id to be Clone, Eq, and Hash.

```rust
pub fn layout_with_steps<'a, T, Emit>(&mut self, nodes: &'a [T], emit: Emit)
where T: GraphNode<Id = Id>, Emit: FnMut(StepDetails<'a, T>),
```

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

### PartialEq Implementation for Renderable

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/struct.Renderable.html

Defines how to check for equality between two Renderable instances using the `==` and `!=` operators.

```rust
fn eq(&self, other: &Renderable) -> bool
```

```rust
fn ne(&self, other: &Rhs) -> bool
```

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

### GraphLayout Default Implementation

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/struct.GraphLayout.html

Provides a `default` method for GraphLayout, allowing for creation of a default instance.

```rust
fn default() -> Self>
```

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

### from_iter<I>(iter: I) -> String

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Creates a `String` from an iterator of `Box<str, A>` where `A` is an allocator.

```APIDOC
## fn from_iter<I>(iter: I) -> String

### Description
Creates a value from an iterator.

### Parameters
#### Path Parameters
- **iter** (I) - Required - An iterator yielding `Box<str, A>` items, where `A` is an allocator.
```

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

### from_iter<I>(iter: I) -> String

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Creates a `String` from an iterator of `&'a char`.

```APIDOC
## fn from_iter<I>(iter: I) -> String

### Description
Creates a value from an iterator.

### Parameters
#### Path Parameters
- **iter** (I) - Required - An iterator yielding `&'a char` items.
```

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

### GraphRenderer::new

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/struct.GraphRenderer.html

Constructs a new GraphRenderer with the provided RenderConfig.

```APIDOC
## GraphRenderer::new

### Description
Constructs a new GraphRenderer instance.

### Method
`new(config: RenderConfig) -> Self`

### Parameters
* `config` (RenderConfig) - The configuration for rendering.
```

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

### pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Tries to reserve capacity for at least `additional` bytes more than the current length. The allocator may reserve more space to speculatively avoid frequent allocations. After calling `try_reserve`, capacity will be greater than or equal to `self.len() + additional` if it returns `Ok(())`. Does nothing if capacity is already sufficient. This method preserves the contents even if an error occurs.

```APIDOC
## pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>

### Description
Tries to reserve capacity for at least `additional` bytes more than the current length. The allocator may reserve more space to speculatively avoid frequent allocations. After calling `try_reserve`, capacity will be greater than or equal to `self.len() + additional` if it returns `Ok(())`. Does nothing if capacity is already sufficient. This method preserves the contents even if an error occurs.

### Errors
If the capacity overflows, or the allocator reports a failure, then an error is returned.

### Examples
```rust
use std::collections::TryReserveError;

fn process_data(data: &str) -> Result<String, TryReserveError> {
    let mut output = String::new();

    // Pre-reserve the memory, exiting if we can't
    output.try_reserve(data.len())?;

    // Now we know this can't OOM in the middle of our complex work
    output.push_str(data);

    Ok(output)
}
```
```

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

### from_iter<I>(iter: I) -> String

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Creates a `String` from an iterator of `&'a str`.

```APIDOC
## fn from_iter<I>(iter: I) -> String

### Description
Creates a value from an iterator.

### Parameters
#### Path Parameters
- **iter** (I) - Required - An iterator yielding `&'a str` items.
```

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

### GraphLayout::layout_steps Method

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/struct.GraphLayout.html

Computes the layout steps for a slice of graph nodes. Requires nodes to implement the GraphNode trait and Id to be Clone, Eq, and Hash.

```rust
pub fn layout_steps<'a, T>(&mut self, nodes: &'a [T]) -> Vec<StepDetails<'a, T>>
where T: GraphNode<Id = Id>,
```

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

### Default Implementation for RenderConfig

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/struct.RenderConfig.html

Provides a default value for RenderConfig, useful for initialization.

```rust
fn default() -> Self
```

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

### String Conversion Methods

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Methods for converting other types into a String.

```APIDOC
## String Conversion Methods

### `to_socket_addrs(&self) -> Result<IntoIter<SocketAddr>, Error>`
Converts this object to an iterator of resolved `SocketAddr`s.

### `try_from(&'a ByteStr) -> Result<String, Utf8Error>`
Performs the conversion from a `ByteStr` into a `String`.

### `try_from(ByteString) -> Result<String, FromUtf8Error>`
Performs the conversion from a `ByteString` into a `String`.

### `try_from(CString) -> Result<String, IntoStringError>`
Converts a `CString` into a `String` if it contains valid UTF-8 data. This method is equivalent to `CString::into_string`.

### `try_from(Vec<u8>) -> Result<String, FromUtf8Error>`
Converts the given `Vec<u8>` into a `String` if it contains valid UTF-8 data.

#### Examples
```rust
let s1 = b"hello world".to_vec();
let v1 = String::try_from(s1).unwrap();
assert_eq!(v1, "hello world");
```
```

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

### Clone Implementation for Glyphs

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/struct.Glyphs.html

Provides methods for cloning Glyphs instances, including a direct clone and a clone_from for efficient copying.

```rust
fn clone(&self) -> Glyphs
```

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

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

### Write Formatted Arguments to String

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Provides glue for using the `write!` macro with String implementors.

```Rust
fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>
```

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

### GraphLayout Clone Implementation

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/struct.GraphLayout.html

Provides a `clone` method for GraphLayout, allowing for duplication of layout instances. Requires the Id type to be Clone.

```rust
fn clone(&self) -> GraphLayout<Id>)
```

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

### Create a New Empty String

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Creates a new empty String without initial allocation. Consider `with_capacity` if the final size is known to avoid reallocations.

```rust
let s = String::new();
```

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

### Clone Implementation for RenderConfig

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/struct.RenderConfig.html

Allows creating a duplicate of a RenderConfig instance.

```rust
fn clone(&self) -> RenderConfig
```

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

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

### From Trait Implementation

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/struct.RenderConfig.html

Converts a value into RenderConfig.

```rust
fn from(t: T) -> T
```

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

### from_iter<T>(iter: T) -> String

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Creates a `String` from an iterator of `AsciiChar`.

```APIDOC
## fn from_iter<T>(iter: T) -> String

### Description
Creates a value from an iterator.

### Parameters
#### Path Parameters
- **iter** (T) - Required - An iterator yielding `AsciiChar` items.
```

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

### from_iter<T>(iter: T) -> String

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Creates a `String` from an iterator of `&'a AsciiChar`.

```APIDOC
## fn from_iter<T>(iter: T) -> String

### Description
Creates a value from an iterator.

### Parameters
#### Path Parameters
- **iter** (T) - Required - An iterator yielding `&'a AsciiChar` items.
```

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

### from_iter<T>(iter: T) -> String

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Creates a `String` from an iterator of `Cow<'a, str>`.

```APIDOC
## fn from_iter<T>(iter: T) -> String

### Description
Creates a value from an iterator.

### Parameters
#### Path Parameters
- **iter** (T) - Required - An iterator yielding `Cow<'a, str>` items.
```

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

### AsRef<Path> for String

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Provides shared access to the string's contents as a `Path`.

```APIDOC
## AsRef<Path> for String

### Description
Provides shared access to the string's contents as a `Path`.

### Method
`as_ref`

### Response
#### Success Response
- `&Path`: A shared reference to the `Path`.

### Response Example
```rust
use std::path::Path;

let s = String::from("path/to/file");
let path: &Path = s.as_ref();
```
```

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

### Display for String

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Allows String values to be formatted for display purposes.

```APIDOC
## Display for String

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

Formats the value using the given formatter.
```

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

### Debug Implementation for StepDetails

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/struct.StepDetails.html

Enables formatted output for debugging StepDetails instances. This allows developers to inspect the state of a StepDetails object during runtime.

```rust
impl<'a, T: Debug> Debug for StepDetails<'a, T>
fn fmt(&self, f: &mut Formatter<'_>) -> Result
```

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

### PartialNe Implementation for ParentAvailability

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/struct.ParentAvailability.html

Tests for inequality between two ParentAvailability instances.

```rust
fn ne(&self, other: &Rhs) -> bool
```

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

### String Comparison Methods

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Provides methods for comparing String values for equality and ordering.

```APIDOC
## String Comparison Methods

### `eq(&self, other: &String) -> bool`
Tests for `self` and `other` values to be equal, and is used by `==`.

### `ne(&self, other: &Rhs) -> bool`
Tests for `!=`. The default implementation is almost always sufficient, and should not be overridden without very good reason.

### `partial_cmp(&self, other: &String) -> Option<Ordering>`
This method returns an ordering between `self` and `other` values if one exists.

### `lt(&self, other: &Rhs) -> bool`
Tests less than (for `self` and `other`) and is used by the `<` operator.

### `le(&self, other: &Rhs) -> bool`
Tests less than or equal to (for `self` and `other`) and is used by the `<=` operator.

### `gt(&self, other: &Rhs) -> bool`
Tests greater than (for `self` and `other`) and is used by the `>` operator.

### `ge(&self, other: &Rhs) -> bool`
Tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator.
```

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

### from(s: &str) -> String

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Converts a string slice `&str` into an owned `String`. The result is allocated on the heap.

```APIDOC
## fn from(s: &str) -> String

### Description
Converts a `&str` into a `String`. The result is allocated on the heap.

### Parameters
#### Path Parameters
- **s** (&str) - Required - The string slice to convert.
```

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

### Node Clone Implementation

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/struct.Node.html

Provides methods for cloning a Node instance, including a direct clone and a clone_from operation.

```rust
fn clone(&self) -> Node
```

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

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

### Try From ByteString to String

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Attempts to convert a ByteString into a String, returning FromUtf8Error on failure.

```Rust
fn try_from( s: ByteString, ) -> Result<String, <String as TryFrom<ByteString>>::Error>
```

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

### Clone Implementation for RowPlan

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/struct.RowPlan.html

Provides methods to create a copy or copy-assignment of a RowPlan instance.

```rust
fn clone(&self) -> RowPlan<'a, T>
```

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

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

### extend_reserve(&mut self, additional: usize)

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Reserves capacity in a String collection for a given number of additional elements. This is a nightly-only experimental API.

```APIDOC
## fn extend_reserve(&mut self, additional: usize)

### Description
Reserves capacity in a collection for the given number of additional elements. This is a nightly-only experimental API.

### Parameters
#### Path Parameters
- **additional** (usize) - Required - The number of additional elements to reserve capacity for.
```

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

### GraphRenderer::render_plan_into Method

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/struct.GraphRenderer.html

Renders a given RowPlan into a mutable string buffer. This method provides read-only access.

```rust
pub fn render_plan_into(&self, plan: &RowPlan<'_, Node>, output: &mut String)>
```

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

### GraphLayout::layout_with_steps

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/struct.GraphLayout.html

Computes the layout steps for a given set of nodes and applies a callback for each step detail. This allows for custom processing of layout step information.

```APIDOC
## GraphLayout::layout_with_steps

### Description
Computes the layout steps for a given set of nodes and applies a callback for each step detail.

### Method
`layout_with_steps<'a, T, Emit>(&mut self, nodes: &'a [T], emit: Emit)`

### Parameters
- `&mut self`: A mutable reference to the `GraphLayout` instance.
- `nodes`: A slice of nodes of type `T`, where `T` must implement `GraphNode` with an `Id` type that matches the `GraphLayout`'s `Id`.
- `emit`: A closure that takes a `StepDetails<'a, T>` and is called for each computed step detail.
```

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

### String::from_utf8_lossy_owned

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Converts a Vec<u8> to a String, substituting invalid UTF-8 sequences with replacement characters. This is a nightly-only experimental API.

```APIDOC
## pub fn from_utf8_lossy_owned(v: Vec<u8>) -> String

### Description
Converts a `Vec<u8>` to a `String`, substituting invalid UTF-8 sequences with replacement characters. See `from_utf8_lossy` for more details. Note that this function does not guarantee reuse of the original `Vec` allocation.

### Method
`String::from_utf8_lossy_owned`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
* **v** (Vec<u8>) - The vector of bytes to convert.

### Request Example
```rust
#![feature(string_from_utf8_lossy_owned)]
let sparkle_heart = vec![240, 159, 146, 150];
let sparkle_heart = String::from_utf8_lossy_owned(sparkle_heart);
assert_eq!(String::from("💖"), sparkle_heart);
```

### Response
#### Success Response (200)
* **String** - The converted String.

#### Response Example
```json
"💖"
```
```

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

### Reserve Capacity for String with usize

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Reserves capacity in a String collection for a specified number of additional elements. This is a nightly-only experimental API.

```Rust
fn extend_reserve(&mut self, additional: usize)
```

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

### pub fn reserve_exact(&mut self, additional: usize)

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Reserves the minimum capacity for at least `additional` bytes more than the current length. Unlike `reserve`, this will not deliberately over-allocate to speculatively avoid frequent allocations. After calling `reserve_exact`, capacity will be greater than or equal to `self.len() + additional`. Does nothing if the capacity is already sufficient.

```APIDOC
## pub fn reserve_exact(&mut self, additional: usize)

### Description
Reserves the minimum capacity for at least `additional` bytes more than the current length. Unlike `reserve`, this will not deliberately over-allocate to speculatively avoid frequent allocations. After calling `reserve_exact`, capacity will be greater than or equal to `self.len() + additional`. Does nothing if the capacity is already sufficient.

### Panics
Panics if the new capacity exceeds `isize::MAX` _bytes_.

### Examples
```rust
let mut s = String::new();

s.reserve_exact(10);

assert!(s.capacity() >= 10);
```
```

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

### AsRef<OsStr> for String

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Provides shared access to the string's contents as an `OsStr`.

```APIDOC
## AsRef<OsStr> for String

### Description
Provides shared access to the string's contents as an `OsStr`.

### Method
`as_ref`

### Response
#### Success Response
- `&OsStr`: A shared reference to the `OsStr`.

### Response Example
```rust
use std::ffi::OsStr;

let s = String::from("hello");
let os_str: &OsStr = s.as_ref();
```
```

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

### GraphLayout::layout_with

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/struct.GraphLayout.html

Computes the layout for a given set of nodes and applies a callback for each row plan. This allows for custom processing of layout results.

```APIDOC
## GraphLayout::layout_with

### Description
Computes the layout for a given set of nodes and applies a callback for each row plan.

### Method
`layout_with<'a, T, Emit>(&mut self, nodes: &'a [T], emit: Emit)`

### Parameters
- `&mut self`: A mutable reference to the `GraphLayout` instance.
- `nodes`: A slice of nodes of type `T`, where `T` must implement `GraphNode` with an `Id` type that matches the `GraphLayout`'s `Id`.
- `emit`: A closure that takes a `RowPlan<'a, T>` and is called for each computed row plan.
```

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

### Convert Cow<'a, str> to String

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Converts a `Cow<'a, str>` into an owned `String`. Clones the string if it is not already owned. Available on non-`no_global_oom_handling` only.

```Rust
fn from(s: Cow<'a, str>) -> String
```

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

### Extend<Cow<'a, str>> for String

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Provides methods to extend a String with Cow<'a, str> values.

```APIDOC
## Extend<Cow<'a, str>> for String
```

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

### GraphLayout::layout_steps

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/struct.GraphLayout.html

Computes the layout steps for a given set of nodes. This method returns detailed step information about the layout process.

```APIDOC
## GraphLayout::layout_steps

### Description
Computes the layout steps for a given set of nodes.

### Method
`layout_steps<'a, T>(&mut self, nodes: &'a [T]) -> Vec<StepDetails<'a, T>>`

### Parameters
- `&mut self`: A mutable reference to the `GraphLayout` instance.
- `nodes`: A slice of nodes of type `T`, where `T` must implement `GraphNode` with an `Id` type that matches the `GraphLayout`'s `Id`.

### Returns
- `Vec<StepDetails<'a, T>>`: A vector of `StepDetails` representing the layout steps.
```

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

### Decompose String into Raw Parts

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Shows how to decompose a String into its raw pointer, length, and capacity. The caller is responsible for managing the memory by reconstructing the String using `from_raw_parts`.

```rust
let s = String::from("hello");

let (ptr, len, cap) = s.into_raw_parts();

let rebuilt = unsafe { String::from_raw_parts(ptr, len, cap) };
assert_eq!(rebuilt, "hello");
```

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

### TryFrom Trait Implementation

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/struct.RenderConfig.html

Attempts to convert a value into RenderConfig, returning a Result.

```rust
type Error = Infallible
```

```rust
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
```

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

### Convert Vec<u8> to String (nightly)

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

An experimental nightly-only API to convert a Vec<u8> into a String, replacing invalid UTF-8 sequences. It may not reuse the original Vec allocation.

```rust
#![feature(string_from_utf8_lossy_owned)]
// some bytes, in a vector
let sparkle_heart = vec![240, 159, 146, 150];

let sparkle_heart = String::from_utf8_lossy_owned(sparkle_heart);

assert_eq!(String::from("💖"), sparkle_heart);
```

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

### PartialEq Implementation for ParentAvailability

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/struct.ParentAvailability.html

Tests for equality between two ParentAvailability instances.

```rust
fn eq(&self, other: &ParentAvailability) -> bool
```

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

### split_off()

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Splits the string into two at a specified byte index, returning the latter part as a new String. The index must be on a UTF-8 code point boundary.

```APIDOC
## split_off()

### Description
Splits the string into two at the given byte index. Returns a newly allocated `String` containing bytes `[at, len)`. `self` will contain bytes `[0, at)`. `at` must be on the boundary of a UTF-8 code point.

### Method
POST

### Endpoint
String::split_off

### Parameters
#### Path Parameters
- **at** (usize) - Required - The byte index at which to split the string.

### Response
#### Success Response (String)
- **split_string** (String) - The portion of the string from the split point to the end.

### Response Example
```json
{
  "split_string": "World!"
}
```
```

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

### Try From CString to String

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Converts a CString into a String if it contains valid UTF-8 data. Equivalent to CString::into_string.

```Rust
fn try_from( value: CString, ) -> Result<String, <String as TryFrom<CString>>::Error>
```

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

### StructuralPartialEq Implementation for TrackCell

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/enum.TrackCell.html

Enables structural equality comparison for TrackCell.

```rust
impl StructuralPartialEq for TrackCell
```

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

### TryFrom Implementation

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/struct.StepDetails.html

Attempts to convert a value into another type, returning a Result. This is used for fallible conversions where the target type might not be representable.

```rust
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
```

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

### Node Constructor

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/struct.Node.html

A constructor function to create a new Node instance. It takes a NodeId (or something convertible to it) and a vector of parent NodeIds.

```rust
pub fn new(id: impl Into<NodeId>, parents: Vec<NodeId>) -> Self
```

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

### Debug Implementation for RenderConfig

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/struct.RenderConfig.html

Enables formatting RenderConfig for debugging purposes.

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

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

### GraphLayout::layout_with Method

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/struct.GraphLayout.html

Computes the layout for a slice of graph nodes and applies a closure for each computed row plan. Requires nodes to implement the GraphNode trait and Id to be Clone, Eq, and Hash.

```rust
pub fn layout_with<'a, T, Emit>(&mut self, nodes: &'a [T], emit: Emit)
where T: GraphNode<Id = Id>, Emit: FnMut(RowPlan<'a, T>),
```

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

### GraphRenderer::render_plan_into

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/struct.GraphRenderer.html

Renders a given RowPlan into a mutable String.

```APIDOC
## GraphRenderer::render_plan_into

### Description
Appends the rendered output of a `RowPlan` to a provided mutable String.

### Method
`render_plan_into(&self, plan: &RowPlan<'_, Node>, output: &mut String)`

### Parameters
* `plan` (&RowPlan<'_, Node>) - The `RowPlan` to render.
* `output` (&mut String) - The mutable String to append the rendered output to.
```

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

### CloneInto Method

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/struct.StepDetails.html

Uses borrowed data to replace owned data, usually by cloning. This method is an alternative to `to_owned` for updating existing owned data.

```rust
fn clone_into(&self, target: &mut T)
```

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

### Clone Implementation for TrackCell

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/enum.TrackCell.html

Provides methods for cloning TrackCell values. `clone` creates a duplicate, while `clone_from` performs copy-assignment.

```rust
fn clone(&self) -> TrackCell
```

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

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

### Into Trait Implementation

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/struct.RenderConfig.html

Converts RenderConfig into another type.

```rust
fn into(self) -> U
```

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

### GraphRenderer::render_to_string

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/struct.GraphRenderer.html

Renders the provided nodes and returns the output as a String.

```APIDOC
## GraphRenderer::render_to_string

### Description
Renders the given nodes and returns the complete output as a String.

### Method
`render_to_string(&mut self, nodes: &[Node]) -> String`

### Parameters
* `nodes` ([]Node) - A slice of `Node` objects to render.

### Returns
* `String` - The rendered output as a String.
```

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

### Debug for String

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Allows String values to be formatted for debugging purposes.

```APIDOC
## Debug for String

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

Formats the value using the given formatter.
```

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

### Convert &String to String

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Converts a `&String` into an owned `String` by cloning. Available on non-`no_global_oom_handling` only.

```Rust
fn from(s: &String) -> String
```

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

### GraphRenderer::config Accessor

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/struct.GraphRenderer.html

Returns a reference to the RenderConfig associated with the GraphRenderer.

```rust
pub fn config(&self) -> &RenderConfig>
```

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

### push_str

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Appends a given string slice onto the end of this `String`.

```APIDOC
## push_str

### Description
Appends a given string slice (`&str`) to the end of the current `String`.

### Method
`push_str(&mut self, string: &str)`

### Parameters
- `string` (&str): The string slice to append.

### Panics
Panics if the new capacity exceeds `isize::MAX` bytes.

### Examples
```rust
let mut s = String::from("foo");
s.push_str("bar");
assert_eq!("foobar", s);
```
```

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

### AsMut<str> for String

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Provides mutable access to the string's underlying `str` slice.

```APIDOC
## AsMut<str> for String

### Description
Provides mutable access to the string's underlying `str` slice.

### Method
`as_mut`

### Response
#### Success Response
- `&mut str`: A mutable reference to the string slice.

### Response Example
```rust
let mut s = String::from("hello");
let mut_str: &mut str = s.as_mut();
mut_str[0..1].make_ascii_uppercase();
assert_eq!(s, "Hello");
```
```

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

### Rust String reserve_exact() basic usage

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Use `reserve_exact` to reserve the minimum capacity for `additional` bytes. Unlike `reserve`, it avoids deliberate over-allocation. Capacity will be at least `self.len() + additional`.

```rust
let mut s = String::new();

s.reserve_exact(10);

assert!(s.capacity() >= 10);
```

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

### Clone for String

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Provides methods for creating deep copies of String values.

```APIDOC
## Clone for String

### fn clone_from(&mut self, source: &String)

Clones the contents of `source` into `self`. This method is preferred over simply assigning `source.clone()` to `self`, as it avoids reallocation if possible.

### fn clone(&self) -> String

Returns a duplicate of the value.
```

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

### from(s: Box<str>) -> String

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/type.NodeId.html

Converts a boxed string slice `Box<str>` into an owned `String`. The `str` slice is owned.

```APIDOC
## fn from(s: Box<str>) -> String

### Description
Converts the given boxed `str` slice to a `String`. It is notable that the `str` slice is owned.

### Parameters
#### Path Parameters
- **s** (Box<str>) - Required - The boxed string slice to convert.

### Request Example
```json
{
  "example": "let s1: String = String::from(\"hello world\");\nlet s2: Box<str> = s1.into_boxed_str();\nlet s3: String = String::from(s2);\n\nassert_eq!(\"hello world\", s3)"
}
```
```

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

### Clone Implementation for Renderable

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/struct.Renderable.html

Provides methods to create a duplicate of a Renderable instance or copy its contents into another instance.

```rust
fn clone(&self) -> Renderable
```

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

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

### Apply Glyph Overrides

Source: https://docs.rs/renderdag/0.3.0/renderdag/graph/struct.Glyphs.html

Applies multiple node and connection glyph overrides simultaneously. Accepts iterators for both node and connection overrides.

```rust
pub fn apply_overrides( &mut self, node_overrides: impl IntoIterator<Item = (NodeKind, char)>, connection_overrides: impl IntoIterator<Item = (ConnectionKind, char)>, )
```
Tokens:
Raw