Struct map::nodes::Node

pub struct Node<T: MapState> {
    pub position: Position,
    pub adjacent_nodes: RefCell<AdjacentNodes<T>>,
    pub status: RefCell<NodeStatus<T>>,
}

Fields

position: Position

adjacent_nodes: RefCell<AdjacentNodes<T>>

status: RefCell<NodeStatus<T>>

Implementations

impl Node<MapStateUninitialized>

pub fn new(position: Position) -> Self

pub fn set_train(&self, train: UnIntiTrainRef) -> Result<()>

pub fn add_link( &self, to: UnIntiNodeRef, direction: Direction, max_speed: i8, length: u32, controller: SwitchControllerOption<MapStateUninitialized> ) -> Result<()>

The nodes can be of two types:

• switch nodes
• non-switch nodes when a link is added it must follow a few rules:
• a non-switch node can have at most one link forward
• a non-switch node can have at most one link backward
• a switch node must have exactly two links forward, (one for each switch position)
• a switch node can have at most one link backward this function enforce all those rules, except the third one, which is enforced inside map_creation_view

pub fn get_next_available_direction(&self) -> Result<Direction>

Trait Implementations

impl<T: Clone + MapState> Clone for Node<T>

fn clone(&self) -> Node<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl CompleteInitialization for Node<MapStateInitialized>

type InitFromType = Node<MapStateUninitialized>

fn complete_initialization( &self, init_from: &Self::InitFromType, map: &Map<MapStateInitialized> )

impl<T: Debug + MapState> Debug for Node<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for Node<T>where T: Deserialize<'de> + MapState,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Initialize for Node<MapStateUninitialized>

type InitializedType = Node<MapStateInitialized>

fn initialize(self) -> Self::InitializedType

impl Into<IntiNodeRef> for &Node<MapStateInitialized>

fn into(self) -> IntiNodeRef

Converts this type into the (usually inferred) input type.

impl<T: PartialEq + MapState> PartialEq<Node<T>> for Node<T>

fn eq(&self, other: &Node<T>) -> bool

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Serialize for Node<T>where T: Serialize + MapState,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.

impl UnInitialize for Node<MapStateInitialized>

type UninitializedType = Node<MapStateUninitialized>

fn un_initialize(self) -> Self::UninitializedType

impl<T: Eq + MapState> Eq for Node<T>

impl<T: MapState> StructuralEq for Node<T>

impl<T: MapState> StructuralPartialEq for Node<T>