Struct TimeTableSystem 

pub struct TimeTableSystem { /* private fields */ }

This is the main Time Table Class.

It implements all of the basic data and algorithms used in the Time Table program.

This class includes code to load a set of stations and the trains that run between these stations, along with code to read and write a time table file and code to create a formatted time table, suitable for printing (by way of LaTeX).

Implementations

impl TimeTableSystem

pub fn old(filename: &str) -> Result<Self, ConstructorError>

The constructor that creates a time table system from an existing file.

The file is read in and the class is properly initialized from the data in the file.

Parameters:

• filename The name of the file to load.

Examples found in repository

examples/LJandBS/main.rs (line 43)

fn main() {
    let mut lj_and_bs = TimeTableSystem::old("LJandBS.tt")
                            .expect("Failed to open time table file");
    lj_and_bs.CreateLaTeXTimetable("LJandBS.tex")
                            .expect("Failed to create time table LaTeX file");
    println!("LJandBS.tex created.  Now use pdflatex to process this file");
    println!("into LJandBS.pdf.  You will need to run pdflatex 2 or three");
    println!("times to get the table of contents properly created.");
}

pub fn new(name: String, timescale: u32, timeinterval: u32) -> Self

The constructor that creates a new, empty time table system from stratch, given a set of esentual parameters.

Parameters:

• name The name of the time table system.
• timescale Number of time units per 24 hours. There are 1440 minutes in 24 hours.
• timeinterval The tick frequency in time units.

Examples found in repository

examples/ValleyFlyer/main.rs (lines 68-69)

fn main() {
    let mut valley_flyer = TimeTableSystem::new(String::from("Northern NE"),
                                                1440,15);
    InsertStations(&mut valley_flyer);
    println!("Number of Stations: {}",valley_flyer.NumberOfStations());
    InsertSouthboundTrains(&mut valley_flyer);
    println!("Number of trains after InsertSouthboundTrains: {}",valley_flyer.NumberOfTrains());
    InsertNorthboundTrains(&mut valley_flyer);
    println!("Number of trains after InsertNorthboundTrains: {}",valley_flyer.NumberOfTrains());
    valley_flyer.SetPrintOption("DirectionName","Southbound");
    valley_flyer.CreateLaTeXTimetable("ValleyFlyer.tex")
                    .expect("Failed to create time table LaTeX file");
}

pub fn AddStation(&mut self, name: String, smile: f64) -> Option<usize>

Add a new station to the system.

Creates a new Station class instance and adds it to the station vector. Stations must be added in order of their scale mile location. If the new station is out of order, -1 is returned and the station is not added!

Parameters:

• name The name of the station.
• smile The scale mile along the route where the station is located.

Examples found in repository

examples/ValleyFlyer/main.rs (line 43)

fn InsertStations(time_table: &mut TimeTableSystem) {
    time_table.AddStation(String::from("Greenfield, MA"),0.0);
    time_table.AddStation(String::from("Northampton, MA"),25.0);
    time_table.AddStation(String::from("Holyoke, MA"),15.0+25.0);
    time_table.AddStation(String::from("Springfield, MA"),28.0+15.0+25.0);
}

pub fn FindStationByName(&self, name: String) -> Option<usize>

Find a station by name.

Returns the index of the station or -1 if the station cannot be found.

Parameters:

• name The name of the station.

pub fn NumberOfStations(&self) -> usize

Number of stations.

Returns the number of stations in the system.

Examples found in repository

examples/ValleyFlyer/main.rs (line 71)

fn main() {
    let mut valley_flyer = TimeTableSystem::new(String::from("Northern NE"),
                                                1440,15);
    InsertStations(&mut valley_flyer);
    println!("Number of Stations: {}",valley_flyer.NumberOfStations());
    InsertSouthboundTrains(&mut valley_flyer);
    println!("Number of trains after InsertSouthboundTrains: {}",valley_flyer.NumberOfTrains());
    InsertNorthboundTrains(&mut valley_flyer);
    println!("Number of trains after InsertNorthboundTrains: {}",valley_flyer.NumberOfTrains());
    valley_flyer.SetPrintOption("DirectionName","Southbound");
    valley_flyer.CreateLaTeXTimetable("ValleyFlyer.tex")
                    .expect("Failed to create time table LaTeX file");
}

pub fn IthStation(&self, i: usize) -> Option<&Station>

Return Ith station object.

Returns the NULL pointer if the index is out of range.

Parameters:

• i The index of the station.

pub fn IthStationMut(&mut self, i: usize) -> Option<&mut Station>

pub fn StationName(&self, i: usize) -> Option<String>

Return the Ith station name.

Returns the NULL pointer if the index is out of range.

Parameters:

• i The index of the station.

pub fn SMile(&self, i: usize) -> Option<f64>

Return the Ith station’s scale mile location.

Returns -1.0 if the index is out of range.

Parameters:

• i The index of the station.

pub fn TotalLength(&self) -> f64

The total length of the route in scale miles.

This is just the scale mile location of the last station along the route.

pub fn DuplicateStationIndex(&self, i: usize) -> Option<usize>

The duplicate station index for a given station.

Only meaningful for out and back type layouts or layouts that have shared trackage. This would be stations along shared trackage. Returns -1 if the index is out of range or if there is not a duplicate station for the ith station.

Parameters:

• i The index of the station.

pub fn SetDuplicateStationIndex(&mut self, i: usize, dup: usize)

Set the duplicate station index for a given station.

Only meaningful for out and back type layouts or layouts that have shared trackage. This would be stations along shared trackage. setting the duplicate station index indicates there is no duplicate station

Parameters:

• i The index of the station to be updated.
• dup The other station index sharing this station location.

pub fn AddStorageTrack( &mut self, i: usize, name: &String, ) -> Option<&mut StorageTrack>

Add a storage track to a station.

Sometimes stations, especially major terminals, have extra tracks for storing terminating and originating trains. Returns the NULL pointer if the index is out of range. Otherwise returns the pointer to the new StorageTrack object.

Parameters:

• i The index of the station to be updated.
• name The name for the new storage track.

pub fn FindStorageTrack(&self, i: usize, name: &String) -> Option<&StorageTrack>

Find a storage track at a station.

Sometimes stations, especially major terminals, have extra tracks for storing terminating and originating trains. Returns the NULL pointer if the index is out of range or if there is no storage track with the specified name. Otherwise the StorageTrack object pointer is returned.

Parameters:

• i The index of the station to be updated.
• name The name of the storage track.

pub fn FindStorageTrack_mut( &mut self, i: usize, name: &String, ) -> Option<&mut StorageTrack>

pub fn AddCab(&mut self, name: String, color: String) -> &Cab

Add a new cab to the system.

With DC systems this would be an actual cab. With DCC systems, this can be used to define a logical operator for the train. The color is used for visual distintion. A pointer to the new cab object is returned.

Parameters:

• name The name of the cab.
• color The color of the cab.

pub fn FindCab(&self, name: &String) -> Option<&Cab>

Find a cab (by name).

Returns the pointer to the named cab or NULL if the cab was not found.

Parameters:

• name The cab name to look for.

pub fn NumberOfCabs(&self) -> usize

The nymber of cabs.

pub fn AddTrain( &mut self, name: String, number: String, speed: u32, classnumber: u32, departure: u32, start: usize, iend: isize, ) -> Result<&Train, AddTrainError>

Add a train to the system, short version.

Creates a new Train opject and adds it to the train map. The short version assumes that the train does not layover at any of the stops. Layover times can be added later. Returns a pointer to the new Train object.

Parameters:

• name The name of the train.
• number The number (or symbol) of the train.
• speed The trains maximum speed.
• classnumber The class (inverse priority) of the train.
• departure The train’s departure time.
• start The train’s origin station index. Defaults to the first station.
• end The train’s destination station index. Defaults to the last station.

Examples found in repository

examples/ValleyFlyer/main.rs (lines 50-51)

fn InsertSouthboundTrains(time_table: &mut TimeTableSystem) {
    time_table.AddTrain(String::from("Valley Flyer"),String::from("479"),60,1,
                        18*60+5,0,3).expect("Failed to insert 479");
    time_table.AddTrain(String::from("Valley Flyer"),String::from("425"),60,1,
                        6*60+5,0,3).expect("Failed to insert 425");
}

fn InsertNorthboundTrains(time_table: &mut TimeTableSystem) {
    time_table.AddTrain(String::from("Valley Flyer"),String::from("494"),60,1,
                        21*60+25,3,0).expect("Failed to insert 494");
    time_table.AddTrain(String::from("Valley Flyer"),String::from("486"),60,1,
                        15*60+15,3,0).expect("Failed to insert 486");
}

pub fn AddTrainLongVersion( &mut self, name: String, number: String, speed: u32, classnumber: u32, departure: u32, start: usize, end: usize, layoverVector: &DoubleVector, cabnameVector: &StringList, storageTrackVector: &StringList, ) -> Result<&Train, AddTrainError>

Add a train to the system, long version (includes storage track checking).

This version includes layover times, cabnames, and storage track assignments. Returns a pointer to the new Train object or the NULL pointer if there was an error, in which case the error message will be stored in the pointer provided.

Parameters:

• name The name of the train.
• number The number (or symbol) of the train.
• speed The trains maximum speed.
• classnumber The class (inverse priority) of the train.
• departure The train’s departure time.
• start The train’s origin station index.
• end The train’s destination station index.
• layoverVector The train’s layover vector.
• cabnameVector The train’s departure cab name vector.
• storageTrackVector The train’s storage track name vector.

pub fn DeleteTrain(&mut self, number: String) -> Result<(), DeleteTrainError>

Delete a train.

Returns true if the train was successfully deleted and false if not. If the train was not deleted, an error message will be provided in the pointer provided.

Parameters:

• number The train number or symbol.

pub fn FindTrainByName(&self, name: &String) -> Option<&Train>

Find a train by name.

Returns the pointer to the named train or NULL if the train was not found.

Parameters:

• name The train name to look for.

pub fn FindTrainByNumber(&self, number: &String) -> Option<&Train>

Find a train by number (or symbol).

Returns the pointer to the train or NULL if the train was not found.

Parameters:

• number The train number (or symbol) to look for.

pub fn NumberOfTrains(&self) -> usize

Return the number of trains.

Examples found in repository

examples/ValleyFlyer/main.rs (line 73)

fn main() {
    let mut valley_flyer = TimeTableSystem::new(String::from("Northern NE"),
                                                1440,15);
    InsertStations(&mut valley_flyer);
    println!("Number of Stations: {}",valley_flyer.NumberOfStations());
    InsertSouthboundTrains(&mut valley_flyer);
    println!("Number of trains after InsertSouthboundTrains: {}",valley_flyer.NumberOfTrains());
    InsertNorthboundTrains(&mut valley_flyer);
    println!("Number of trains after InsertNorthboundTrains: {}",valley_flyer.NumberOfTrains());
    valley_flyer.SetPrintOption("DirectionName","Southbound");
    valley_flyer.CreateLaTeXTimetable("ValleyFlyer.tex")
                    .expect("Failed to create time table LaTeX file");
}

pub fn NumberOfNotes(&self) -> usize

Return the number of notes.

pub fn Note(&self, i: usize) -> Option<String>

Return the ith note (1-based!) as a string. , Returns the NULL pointer if the index is out of range.

Parameters:

• i The note index. The first note is at index 1, not 0!.

pub fn AddNote(&mut self, newnote: String) -> usize

Add a note to the notes vector.

Parameters:

• newnote The text of the new note.

pub fn SetNote(&mut self, i: usize, note: String) -> bool

Set the ith note (1-based!).

Updates the text of the specificed note. Returns true if the note was updated or false if the index was out of range.

Parameters:

• i The note index. The first note is at index 1, not 0!.
• note The new text for the note.

pub fn GetPrintOption(&self, key: &str) -> Option<&String>

Fetch a print option.

Returns the value of a specified print option or the empty string if the print option was not found.

Parameters:

• key The name of the print option.

pub fn SetPrintOption(&mut self, key: &str, value: &str)

Set a print option.

Sets the value of a print option. Creates a new hash table element if the specified print option does not already exist.

Parameters:

• key The name of the print option to be set.
• value The value to set the print option to.

Examples found in repository

examples/ValleyFlyer/main.rs (line 76)

fn main() {
    let mut valley_flyer = TimeTableSystem::new(String::from("Northern NE"),
                                                1440,15);
    InsertStations(&mut valley_flyer);
    println!("Number of Stations: {}",valley_flyer.NumberOfStations());
    InsertSouthboundTrains(&mut valley_flyer);
    println!("Number of trains after InsertSouthboundTrains: {}",valley_flyer.NumberOfTrains());
    InsertNorthboundTrains(&mut valley_flyer);
    println!("Number of trains after InsertNorthboundTrains: {}",valley_flyer.NumberOfTrains());
    valley_flyer.SetPrintOption("DirectionName","Southbound");
    valley_flyer.CreateLaTeXTimetable("ValleyFlyer.tex")
                    .expect("Failed to create time table LaTeX file");
}

pub fn WriteNewTimeTableFile( &mut self, filename: &String, setfilename: bool, ) -> Result<()>

Write out a Time Table System to a new file.

The current contents of the time table is written to a new time table file. Returns true if successful and false if not.

Parameters:

• filename The name of the file to write (if empty, use existing name, if available).
• setfilename Change the filename if true.

pub fn TimeScale(&self) -> u32

Return time scale.

pub fn TimeInterval(&self) -> u32

Return time interval.

pub fn Name(&self) -> String

Return the name of the system.

pub fn Filename(&self) -> String

Return file pathname.

pub fn StationsIter(&self) -> Iter<'_, Station>

pub fn StationsIter_mut(&mut self) -> IterMut<'_, Station>

pub fn CabsIter(&self) -> Iter<'_, String, Cab>

pub fn CabsIter_mut(&mut self) -> IterMut<'_, String, Cab>

pub fn TrainsIter(&self) -> Iter<'_, String, Train>

pub fn TrainsIter_mut(&mut self) -> IterMut<'_, String, Train>

pub fn NotesIter(&self) -> Iter<'_, String>

pub fn NotesIter_mut(&mut self) -> IterMut<'_, String>

pub fn PrintOptionsIter(&self) -> Iter<'_, String, String>

pub fn PrintOptionsIter_mut(&mut self) -> IterMut<'_, String, String>

pub fn CreateLaTeXTimetable( &mut self, filename: &str, ) -> Result<(), CreateLaTeXError>

Create a LaTeX file for generating a (hard copy) Employee Timetable.

This method create a LaTeX source file from the information in the time table structure. It access various print options to control how the LaTeX file is generated.

Parameters:

• filename The name of the LaTeX file to create.

Examples found in repository

examples/LJandBS/main.rs (line 45)

fn main() {
    let mut lj_and_bs = TimeTableSystem::old("LJandBS.tt")
                            .expect("Failed to open time table file");
    lj_and_bs.CreateLaTeXTimetable("LJandBS.tex")
                            .expect("Failed to create time table LaTeX file");
    println!("LJandBS.tex created.  Now use pdflatex to process this file");
    println!("into LJandBS.pdf.  You will need to run pdflatex 2 or three");
    println!("times to get the table of contents properly created.");
}

examples/ValleyFlyer/main.rs (line 77)

fn main() {
    let mut valley_flyer = TimeTableSystem::new(String::from("Northern NE"),
                                                1440,15);
    InsertStations(&mut valley_flyer);
    println!("Number of Stations: {}",valley_flyer.NumberOfStations());
    InsertSouthboundTrains(&mut valley_flyer);
    println!("Number of trains after InsertSouthboundTrains: {}",valley_flyer.NumberOfTrains());
    InsertNorthboundTrains(&mut valley_flyer);
    println!("Number of trains after InsertNorthboundTrains: {}",valley_flyer.NumberOfTrains());
    valley_flyer.SetPrintOption("DirectionName","Southbound");
    valley_flyer.CreateLaTeXTimetable("ValleyFlyer.tex")
                    .expect("Failed to create time table LaTeX file");
}

Trait Implementations

impl Clone for TimeTableSystem

fn clone(&self) -> TimeTableSystem

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TimeTableSystem

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

Formats the value using the given formatter.

impl PartialEq for TimeTableSystem

fn eq(&self, other: &TimeTableSystem) -> 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 StructuralPartialEq for TimeTableSystem