Struct advent_of_code_2021::day_22::Cuboid

struct Cuboid {
    x_min: isize,
    x_max: isize,
    y_min: isize,
    y_max: isize,
    z_min: isize,
    z_max: isize,
}

Represents a cuboid as its range of co-ordinates on each axis. Both values are inclusive.

Fields

x_min: isize

x_max: isize

y_min: isize

y_max: isize

z_min: isize

z_max: isize

Implementations

impl Cuboid

fn new(
    x_min: isize,
    x_max: isize,
    y_min: isize,
    y_max: isize,
    z_min: isize,
    z_max: isize
) -> Cuboid

Utility so that a Cuboid can be created on a single line (struct literals are always split into multilines by rust-fmt)

fn intersect(&self, other: &Cuboid) -> Option<Cuboid>

Return the Cuboid region where this and another Cuboid overlap, if they do.

fn diff_and_split(&self, other: &Cuboid) -> Vec<Cuboid>

If there is an overlap with the incoming Cuboid, return a list of Cuboid slices that do not that do not intersect, if any. If there is no intersection return this cube, unaffected.

E.g. in 2D do the following

-----------------          self.dff_and_split(&other);
| self          |
|   ---------   |
|   | other |   |
|   ---------   |
|               |
-----------------

----| |-------| |----      First split on the x axis creating rectangles  
| l | |       | | r |      left and right with their x bounds set to just
| e | |-------| | i |      outside the intersecting region.
| f | | other | | g |
| t | |-------| | h |
|   | |       | | t |
----| |-------| |----

      ----------
      |  top   |
----| ---------- |----     Then split on the y-axis creating rectangles   
| l |            | r |     top and bottom. Their y bounds set to just
| e | ---------- | i |     outside the intersecting region, but their x
| f | | other  | | g |     bounds are the same as the intersecting region's
| t | ---------- | h |     so that they don't overlap left and right at the
|   |            | t |     corners
----| ---------- |----
      | bottom |
      ----------

----| ---------- |----      Just return the slices from self. Other will
| l | |  top   | | r |      only be added to the next iteration if it is
| e | ---------- | i |      'on', which is done elsewhere.
| f |            | g |      
| t | ---------- | h |
|   | | bottom | | t |
----| ---------- |----

Note: Not all slices always get returned e.g. a corner intersect
just creates two slices.

                                       -----            
                                       |top|            
---------|      ----| |----      ----| -----      ----| -----                   
|  self  |      | L | |   |      | L |            | L | |top|
|   -------- => |   | |------ => |   | ------- => |   | -----
----|other |    |---| |other|    ----| |other|    ----|
    --------          |------          |------         

The above is expanded to three dimensions, but the logic is the same.

fn volume(&self) -> isize

Calculates the volume of this Cuboid. Note the +1s because both limits are inclusive.

Trait Implementations

impl Clone for Cuboid

fn clone(&self) -> Cuboid

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Cuboid

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

Formats the value using the given formatter.

impl PartialEq<Cuboid> for Cuboid

fn eq(&self, other: &Cuboid) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Cuboid) -> bool

This method tests for !=.

impl Copy for Cuboid

impl Eq for Cuboid

impl StructuralEq for Cuboid

impl StructuralPartialEq for Cuboid