Trait Mesh

pub trait Mesh {
    type Node;
    type Id: RemoteMessage;
    type Sliced<'a>: Mesh<Node = Self::Node> + 'a
       where Self: 'a;

    // Required methods
    fn shape(&self) -> &Shape;
    fn select<R: Into<Range>>(
        &self,
        label: &str,
        range: R,
    ) -> Result<Self::Sliced<'_>, ShapeError>;
    fn get(&self, index: usize) -> Option<Self::Node>;
    fn id(&self) -> Self::Id;

    // Provided method
    fn iter(&self) -> MeshIter<'_, Self>  { ... }
}

A mesh of nodes, organized into the topology described by its shape (see Shape).

Required Associated Types

type Node

The type of the node contained in the mesh.

type Id: RemoteMessage

The type of identifiers for this mesh.

type Sliced<'a>: Mesh<Node = Self::Node> + 'a where Self: 'a

The type of a slice of this mesh. Slices should not outlive their parent mesh.

Required Methods

fn shape(&self) -> &Shape

The shape of this mesh.

fn select<R: Into<Range>>( &self, label: &str, range: R, ) -> Result<Self::Sliced<'_>, ShapeError>

Sub-slice this mesh, specifying the included ranges for the dimension with the labeled name.

fn get(&self, index: usize) -> Option<Self::Node>

Retrieve contained node at the provided index. The index is relative to the shape of the mesh.

fn id(&self) -> Self::Id

The global identifier for this mesh.

Provided Methods

fn iter(&self) -> MeshIter<'_, Self>

Iterate over all the nodes in this mesh.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl Mesh for ProcMesh

type Node = ProcId

type Id = ProcMeshId

type Sliced<'a> = SlicedProcMesh<'a>

impl Mesh for SlicedProcMesh<'_>

type Node = ProcId

type Id = ProcMeshId

type Sliced<'b> = SlicedProcMesh<'b> where Self: 'b

impl<'a, A: RemoteActor> Mesh for RootActorMesh<'a, A>

type Node = ActorRef<A>

type Id = ActorMeshId

type Sliced<'b> = SlicedActorMesh<'b, A> where 'a: 'b

impl<A: RemoteActor> Mesh for SlicedActorMesh<'_, A>

type Node = ActorRef<A>

type Id = ActorMeshId

type Sliced<'b> = SlicedActorMesh<'b, A> where Self: 'b