Enum Node

pub enum Node {
    Bos(Bos),
    Eos(Eos),
    Middle(Middle),
}

A node.

Variants

Bos(Bos)

The BOS (Beginning of Sequence) node.

Eos(Eos)

The EOS (Ending of Sequence) node.

Middle(Middle)

The middle node.

Implementations

impl Node

pub const fn bos(preceding_edge_costs: Rc<Vec<i32>>) -> Self

Creates a BOS (Beginning of Sequence).

Arguments

• preceding_edge_costs - Preceding edge costs.

pub const fn eos( preceding_step: usize, preceding_edge_costs: Rc<Vec<i32>>, best_preceding_node: usize, path_cost: i32, ) -> Self

Creates an EOS (Ending of Sequence).

Arguments

• preceding_step - An index of a preceding step.
• preceding_edge_costs - Preceding edge costs.
• best_preceding_node - An index of a best preceding node.
• path_cost - A path cost.

pub fn new( key: Box<dyn Input>, value: Box<dyn Any>, index_in_step: usize, preceding_step: usize, preceding_edge_costs: Rc<Vec<i32>>, best_preceding_node: usize, node_cost: i32, path_cost: i32, ) -> Self

Creates a node.

Arguments

• key - A key.
• value - A value.
• index_in_step - An index in the step.
• preceding_step - An index of a preceding step.
• preceding_edge_costs - Preceding edge costs.
• best_preceding_node - An index of a best preceding node.
• node_cost - A node cost.
• path_cost - A path cost.

pub fn new_with_entry( entry: Rc<Entry>, index_in_step: usize, preceding_step: usize, preceding_edge_costs: Rc<Vec<i32>>, best_preceding_node: usize, path_cost: i32, ) -> Result<Self, Error>

Creates a node with a vocabulary entry.

Errors

• When entry is BOS or EOS.

pub fn key(&self) -> Option<&dyn Input>

Returns the key.

Returns

The key.

pub fn value(&self) -> Option<&dyn Any>

Returns the value.

Returns

The value.

Examples found in repository

examples/transfer_trains/main.rs (line 203)

fn enumerate_trips(lattice: &Lattice, eos_node: Node, trip_capacity: usize) -> Vec<Trip> {
    let iter = NBestIterator::new(lattice, eos_node, Box::new(Constraint::new()));
    let mut trips = Vec::with_capacity(trip_capacity);
    let mut duplication_checker = HashSet::<String>::new();
    for path in iter {
        if trips.len() >= trip_capacity || path.cost() >= 1440 {
            break;
        }

        let mut trip = Trip {
            sections: Vec::new(),
            cost: 0,
        };
        for node in path.nodes() {
            let section = if let Some(node_value) = node.value() {
                if let Some(section) = node_value.downcast_ref::<Section>() {
                    section
                } else {
                    continue;
                }
            } else {
                continue;
            };

            if trip.sections.is_empty()
                || trip
                    .sections
                    .last()
                    .unwrap_or_else(|| unreachable!("trip.sections must not empty."))
                    .train_number
                    != section.train().number()
            {
                trip.sections.push(TripSection {
                    train_number: section.train().number().to_string(),
                    train_name: section.train().name().to_string(),
                    departure_time: section.train().stops()[section.from()]
                        .departure_time()
                        .unwrap_or_else(|| unreachable!("departure_time must not None.")),
                    departure_station: section.from(),
                    arrival_time: section.train().stops()[section.to()]
                        .arrival_time()
                        .unwrap_or_else(|| unreachable!("arrival_time must not None.")),
                    arrival_station: section.to(),
                });
            } else {
                let last_section = trip
                    .sections
                    .last_mut()
                    .unwrap_or_else(|| unreachable!("trip.sections must not empty."));
                last_section.arrival_time = section.train().stops()[section.to()]
                    .arrival_time()
                    .unwrap_or_else(|| unreachable!("arrival_time must not None."));
                last_section.arrival_station = section.to();
            }
        }
        trip.cost = path.cost();

        let first_section = trip
            .sections
            .first()
            .unwrap_or_else(|| unreachable!("trip.sections must not empty."));
        let last_section = trip
            .sections
            .last()
            .unwrap_or_else(|| unreachable!("trip.sections must not empty."));
        if duplication_checker.contains(&first_section.train_number)
            || duplication_checker.contains(&last_section.train_number)
        {
            continue;
        }
        let _ = duplication_checker.insert(first_section.train_number.clone());
        let _ = duplication_checker.insert(last_section.train_number.clone());
        trips.push(trip);
    }
    trips
}

pub const fn index_in_step(&self) -> usize

Returns the index in the step.

Returns

The index in the step.

pub const fn preceding_step(&self) -> usize

Returns the preceding step.

Returns

The preceding step.

pub fn preceding_edge_costs(&self) -> &Vec<i32>

Returns the preceding edge costs.

Returns

The preceding edge costs.

pub const fn best_preceding_node(&self) -> usize

Returns the index of the best preceding node.

Returns

The index of the best preceding node.

pub fn node_cost(&self) -> i32

Returns the node cost.

Returns

The node cost.

pub const fn path_cost(&self) -> i32

Returns the path cost.

Returns

The path cost.

pub const fn is_bos(&self) -> bool

Returns true if this node is the BOS.

Returns

true if this node is the BOS.

Trait Implementations

impl Clone for Node

fn clone(&self) -> Node

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Node

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

Formats the value using the given formatter.

impl PartialEq for Node

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for Node

impl StructuralPartialEq for Node