Struct ghx_proc_gen::generator::socket::SocketCollection

pub struct SocketCollection { /* private fields */ }

Used to create one or more Socket. Created sockets can then be used to define super::model::Model and define connections between them.

Implementations

impl SocketCollection

pub fn new() -> Self

Creates a new SocketCollection

pub fn create(&mut self) -> Socket

Creates a new Socket in the collection and returns it

pub fn add_connection<I>(&mut self, from: Socket, to: I) -> &mut Self

where I: IntoIterator<Item = Socket>,

Adds a connection between two sockets. super::model::Model with sockets from can connect to model with sockets to and vice versa.

• There is no direction in the relation, adding a connection froma to b also adds a connection from b to a
• By default (until the connection is explicitly added), a socket is not “compatible” with itself.

Example

use ghx_proc_gen::generator::socket::SocketCollection;

let mut sockets = SocketCollection::new();
let a = sockets.create();
let b = sockets.create();
sockets.add_connection(a, vec![a, b]);
// `a` can be connected to `a` and `b`
// `b` can be connected to `a`

pub fn add_connections<I, J>(&mut self, connections: I) -> &mut Self

where I: IntoIterator<Item = (Socket, J)>, J: IntoIterator<Item = Socket>,

Same as add_connection but accept multiple connections definitions at the same time.

Example

use ghx_proc_gen::generator::socket::SocketCollection;

let mut sockets = SocketCollection::new();
let (a, b, c) = (sockets.create(), sockets.create(), sockets.create());
sockets.add_connections(vec![
    (a, vec![a, b]),
    (b, vec![c])
]);
// `a` can be connected to `a` and `b`
// `b` can be connected to `a` and `c`
// `c` can be connected to `b`

pub fn add_rotated_connection( &mut self, from: Socket, to: Vec<Socket> ) -> &mut Self

Adds a connection between all possible rotations of two sockets that are on the rotation axis of the super::Rules. super::model::Model with sockets from can connect to model with sockets to and vice versa.

• There is no direction in the relation, adding a connection froma to b also adds a connection from b to a
• By default (until the connection is explicitly added), a socket is not “compatible” with itself.

Example

use ghx_proc_gen::generator::{socket::{SocketCollection, SocketsCartesian3D}, model::ModelCollection};

let mut sockets = SocketCollection::new();
let (side_a, vertical_a) = (sockets.create(), sockets.create());
let (side_b, vertical_b) = (sockets.create(), sockets.create());

// If Y+ is our rotation axis. We could have such models:
let mut models = ModelCollection::new();
let model_a = models.create(SocketsCartesian3D::Simple {
    x_pos: side_a,
    x_neg: side_a,
    z_pos: side_a,
    z_neg: side_a,
    y_pos: vertical_a,
    y_neg: vertical_a,
}).with_all_rotations();
let model_b = models.create(SocketsCartesian3D::Simple {
    x_pos: side_b,
    x_neg: side_b,
    z_pos: side_b,
    z_neg: side_b,
    y_pos: vertical_b,
    y_neg: vertical_b,
}).with_all_rotations();

sockets.add_rotated_connection(vertical_a, vec![vertical_b]);
// `model_a` and `model_b` can now be stacked on top of each other (no matter their rotations)
// Note: here two `model_a` cannot be stacked on top of each other since `vertical_a` was not said to be connected to itself.

pub fn add_rotated_connections<I>(&mut self, connections: I) -> &mut Self

where I: IntoIterator<Item = (Socket, Vec<Socket>)>,

Same as add_rotated_connection but accepts multiple connections definitions at the same time.

pub fn add_constrained_rotated_connection( &mut self, from: Socket, relative_rotations: Vec<ModelRotation>, to: Vec<Socket> ) -> &mut Self

Similar to add_rotated_connection but with additional constraints.

Adds a connection between only the specified relative_rotations of two sockets that are on the rotation axis of the super::Rules. super::model::Model with sockets from, with a given relative rotation to socket to, can connect to model with sockets to (and vice versa with the opposite relative rotation).

relative_rotations should be defined with regard to rotation ModelRotation::Rot0 of to. So a value of ModelRotation::Rot90 in relative_rotations means that a from socket can be connected to a to socket if and only if the from socket is rotated 90° more than the to socket, no matter their absolute rotations.

• There is no direction in the relation, adding a connection froma to b also adds a connection from b to a (here with the opposite relative rotation)
• By default (until the connection is explicitly added), a socket is not “compatible” with itself.

Trait Implementations

impl Clone for SocketCollection

fn clone(&self) -> SocketCollection

Returns a copy of the value.

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

Performs copy-assignment from source.