Trait UnitGraph 

pub trait UnitGraph {
    // Required methods
    fn add_course(&mut self, course_id: Ustr) -> Result<(), UnitGraphError>;
    fn add_lesson(
        &mut self,
        lesson_id: Ustr,
        course_id: Ustr,
    ) -> Result<(), UnitGraphError>;
    fn add_exercise(
        &mut self,
        exercise_id: Ustr,
        lesson_id: Ustr,
    ) -> Result<(), UnitGraphError>;
    fn add_dependencies(
        &mut self,
        unit_id: Ustr,
        unit_type: UnitType,
        dependencies: &[Ustr],
    ) -> Result<(), UnitGraphError>;
    fn add_encompassed(
        &mut self,
        unit_id: Ustr,
        dependencies: &[Ustr],
        encompassed: &[(Ustr, f32)],
    ) -> Result<(), UnitGraphError>;
    fn set_encompasing_equals_dependency(&mut self);
    fn encompasing_equals_dependency(&self) -> bool;
    fn add_superseded(&mut self, unit_id: Ustr, superseded: &[Ustr]);
    fn get_unit_type(&self, unit_id: Ustr) -> Option<UnitType>;
    fn get_course_lessons(&self, course_id: Ustr) -> Option<UstrSet>;
    fn update_starting_lessons(&mut self);
    fn get_starting_lessons(&self, course_id: Ustr) -> Option<UstrSet>;
    fn get_lesson_course(&self, lesson_id: Ustr) -> Option<Ustr>;
    fn get_lesson_exercises(&self, lesson_id: Ustr) -> Option<UstrSet>;
    fn get_exercise_lesson(&self, exercise_id: Ustr) -> Option<Ustr>;
    fn get_dependencies(&self, unit_id: Ustr) -> Option<UstrSet>;
    fn get_dependents(&self, unit_id: Ustr) -> Option<UstrSet>;
    fn get_dependency_sinks(&self) -> UstrSet;
    fn get_encompasses(&self, unit_id: Ustr) -> Option<Vec<(Ustr, f32)>>;
    fn get_encompassed_by(&self, unit_id: Ustr) -> Option<Vec<(Ustr, f32)>>;
    fn get_supersedes(&self, unit_id: Ustr) -> Option<UstrSet>;
    fn get_superseded_by(&self, unit_id: Ustr) -> Option<UstrSet>;
    fn check_cycles(&self) -> Result<(), UnitGraphError>;
    fn generate_dot_graph(&self, courses_only: bool) -> String;
}

Stores the units and their dependency relationships (for lessons and courses only, since exercises do not define any dependencies). It provides basic functions to update the graph and retrieve information about it for use during scheduling and student’s requests.

The operations that update the graph are only used when reading the Trane library during startup. A user that copies new courses to an existing and currently opened library will need to restart Trane to see the changes take effect.

Required Methods

fn add_course(&mut self, course_id: Ustr) -> Result<(), UnitGraphError>

Adds a new course to the unit graph.

fn add_lesson( &mut self, lesson_id: Ustr, course_id: Ustr, ) -> Result<(), UnitGraphError>

Adds a new lesson to the unit graph. It also takes the ID of the course to which this lesson belongs.

fn add_exercise( &mut self, exercise_id: Ustr, lesson_id: Ustr, ) -> Result<(), UnitGraphError>

Adds a new exercise to the unit graph. It also takes the ID of the lesson to which this exercise belongs.

fn add_dependencies( &mut self, unit_id: Ustr, unit_type: UnitType, dependencies: &[Ustr], ) -> Result<(), UnitGraphError>

Takes a unit and its dependencies and updates the graph accordingly. Returns an error if unit_type is UnitType::Exercise as only courses and lessons are allowed to have dependencies. An error is also returned if the unit was not previously added by calling one of add_course or add_lesson.

fn add_encompassed( &mut self, unit_id: Ustr, dependencies: &[Ustr], encompassed: &[(Ustr, f32)], ) -> Result<(), UnitGraphError>

Adds the list of encompassed units for the given unit to the graph. Dependencies not in the list of encompassed units are added with a default weight of 1.0. Returns an error if any of the weights are not within the range [0.0, 1.0].

fn set_encompasing_equals_dependency(&mut self)

Tells UnitGraph that the encompassing and dependency graphs are the same. That is, no manifest explicitly declared encompassed units. In this case, the encompassing graph is identical to the dependency graph with all weights set to 1.0. The caller should use this function after building the full graph to avoid the overhead of storing two identical graphs.

fn encompasing_equals_dependency(&self) -> bool

Whether the encompassing and dependency graphs are effectively the same.

fn add_superseded(&mut self, unit_id: Ustr, superseded: &[Ustr])

Adds the list of superseded units for the given unit to the graph.

fn get_unit_type(&self, unit_id: Ustr) -> Option<UnitType>

Returns the type of the given unit.

fn get_course_lessons(&self, course_id: Ustr) -> Option<UstrSet>

Returns the lessons belonging to the given course.

fn update_starting_lessons(&mut self)

Updates the starting lessons for all courses. The starting lessons of the course are those of its lessons that should be practiced first when the course is introduced to the student. The scheduler uses them to traverse through the other lessons in the course in the correct order. This function should be called once after all the courses and lessons have been added to the graph.

fn get_starting_lessons(&self, course_id: Ustr) -> Option<UstrSet>

Returns the starting lessons for the given course.

fn get_lesson_course(&self, lesson_id: Ustr) -> Option<Ustr>

Returns the course to which the given lesson belongs.

fn get_lesson_exercises(&self, lesson_id: Ustr) -> Option<UstrSet>

Returns the exercises belonging to the given lesson.

fn get_exercise_lesson(&self, exercise_id: Ustr) -> Option<Ustr>

Returns the lesson to which the given exercise belongs.

fn get_dependencies(&self, unit_id: Ustr) -> Option<UstrSet>

Returns the weights of the dependencies of the given unit.

fn get_dependents(&self, unit_id: Ustr) -> Option<UstrSet>

Returns all the units which depend on the given unit.

fn get_dependency_sinks(&self) -> UstrSet

Returns the dependency sinks of the graph. A dependency sink is a unit with no dependencies from which a walk of the entire unit graph needs to start. Because the lessons in a course implicitly depend on their course, properly initialized lessons do not belong to this set.

This set also includes the units that are mentioned as dependencies of other units but are never added to the graph because they are missing from the course library. Those units are added as dependency sinks so that the scheduler can reach their dependents, which are part of the library.

fn get_encompasses(&self, unit_id: Ustr) -> Option<Vec<(Ustr, f32)>>

Returns the units that this unit encompasses.

fn get_encompassed_by(&self, unit_id: Ustr) -> Option<Vec<(Ustr, f32)>>

Returns the units that the given unit is encompassed by.

fn get_supersedes(&self, unit_id: Ustr) -> Option<UstrSet>

Returns the units that this unit supersedes.

fn get_superseded_by(&self, unit_id: Ustr) -> Option<UstrSet>

Returns the units that the given unit is superseded by.

fn check_cycles(&self) -> Result<(), UnitGraphError>

Performs a cycle check on the graph, done currently when opening the Trane library to prevent any infinite traversal of the graph and immediately inform the user of the issue.

fn generate_dot_graph(&self, courses_only: bool) -> String

Generates a DOT graph of the dependent graph. DOT files are used by Graphviz to visualize a graph, in this case the dependent graph. This operation was suggested in issue #13 in the trane-cli repo.

This allows users to have some way to visualize the graph without having to implement such a feature and depend on Graphviz instead.

The dependent graph is outputted instead of the dependency graph so that the output is easier to read. If you follow the arrows, then you are traversing the path that students must take to master a skill.

If courses_only is true, only courses will be included in the graph.

Implementors

impl UnitGraph for Trane

impl UnitGraph for InMemoryUnitGraph