Session 8

// student_registration.cpp -- MCSL-222 Session 8, Q19
// Figure 1.15 (Student Registration) implemented in C++17.
// Build: clang++ -std=c++17 -Wall -Wextra -o student_registration student_registration.cpp
//
// Mapping used throughout:
//   class            -> class
//   attribute        -> public data member (same name as the figure)
//   operation        -> member function (same name as the figure)
//   association end  -> pointer for 1 / 0..1, std::vector of pointers for * / 1..*
// Objects are created in main and never deleted here; the pointers are links only.

#include <algorithm>
#include <iostream>
#include <string>
#include <vector>

class School;
class Faculty;
class Programme;
class Course;
class Student;

// Removes one link from an association vector. Every remove* operation uses it.
template <class T>
static void unlink(std::vector<T*>& v, T* p) {
    v.erase(std::remove(v.begin(), v.end(), p), v.end());
}

// ---------------------------------------------------------------- Course
class Course {
public:
    std::string courseCode;
    std::string courseName;
    std::vector<Programme*> programmes;  // Course (1) <>-- (*) Programme, as drawn

    Course(std::string code, std::string name)
        : courseCode(std::move(code)), courseName(std::move(name)) {}

    // The four operations in the figure manage the list of courses, so they
    // work on one shared catalogue rather than on a single Course object.
    inline static std::vector<Course*> catalogue;

    static void addCourse(Course& c) { catalogue.push_back(&c); }
    static void removeCourse(Course& c) { unlink(catalogue, &c); }
    static Course* getCoursebyName(const std::string& name) {
        for (Course* c : catalogue)
            if (c->courseName == name) return c;
        return nullptr;
    }
    static Course* getCoursebyCode(const std::string& code) {
        for (Course* c : catalogue)
            if (c->courseCode == code) return c;
        return nullptr;
    }
};

// ------------------------------------------------------------- Programme
class Programme {
public:
    std::string programID;
    std::string ProgramName;
    std::vector<School*> schools;  // School (1..*) --- (1..*) Programme

    Programme(std::string id, std::string name)
        : programID(std::move(id)), ProgramName(std::move(name)) {}
};

// --------------------------------------------------------------- Faculty
class Faculty {
public:
    std::string facultyID;
    std::string facultyName;
    std::string schoolName;
    Faculty* hod = nullptr;         // HOD 0..1 (reflexive association)
    std::vector<Course*> courses;   // Teaches: Faculty (1..*) --> Course

    Faculty(std::string id, std::string name)
        : facultyID(std::move(id)), facultyName(std::move(name)) {}

    void teaches(Course& c) { courses.push_back(&c); }
};

// ---------------------------------------------------------------- School
class School {
public:
    std::string name;
    std::vector<Faculty*> faculties;     // AssignTo: School (1) <>-- (1..*) Faculty
    std::vector<Programme*> programmes;  // School (1..*) --- (1..*) Programme

    explicit School(std::string n) : name(std::move(n)) {}

    void addFaculty(Faculty& f) {
        faculties.push_back(&f);
        f.schoolName = name;  // the figure keeps the school name inside Faculty
    }
    void removeFaculty(Faculty& f) {
        unlink(faculties, &f);
        f.schoolName.clear();
    }
    void addProgramme(Programme& p) {  // both ends are 1..*, so update both
        programmes.push_back(&p);
        p.schools.push_back(this);
    }
    void removeProgramme(Programme& p) {
        unlink(programmes, &p);
        unlink(p.schools, this);
    }
};

// --------------------------------------------------------------- Student
class Student {
public:
    int stuID;
    std::string name;
    std::string address;
    Programme* programme = nullptr;  // enrol: Student --> Programme

    Student(int id, std::string n, std::string addr)
        : stuID(id), name(std::move(n)), address(std::move(addr)) {}

    // Constraint {one student per programme}: a registration binds a student
    // to exactly one programme, so a second enrol() is refused.
    bool enrol(Programme& p) {
        if (programme != nullptr) {
            std::cout << "  refused: " << name << " is already enrolled in "
                      << programme->ProgramName << " (one student per programme)\n";
            return false;
        }
        programme = &p;
        return true;
    }
};

// ------------------------------------------------------------ University
class University {
public:
    std::string name;
    std::string address;
    int phone;
    std::vector<School*> schools;    // has: University (1) <>-- (1..*) School
    std::vector<Student*> students;  // registration: University (1) <>-- (*) Student

    University(std::string n, std::string addr, int ph)
        : name(std::move(n)), address(std::move(addr)), phone(ph) {}

    void addSchool(School& s) { schools.push_back(&s); }
    void removeSchool(School& s) { unlink(schools, &s); }
    void addStudent(Student& s) { students.push_back(&s); }
    void removeStudent(Student& s) { unlink(students, &s); }
    School* getSchool(const std::string& n) const {
        for (School* s : schools)
            if (s->name == n) return s;
        return nullptr;
    }
    const std::vector<School*>& getAllSchool() const { return schools; }
    Student* getStudent(int id) const {
        for (Student* s : students)
            if (s->stuID == id) return s;
        return nullptr;
    }
};

// ------------------------------------------------------------------ main
static void printUniversity(const University& u) {
    std::cout << u.name << ", " << u.address << ", phone " << u.phone << "\n";
    for (const School* s : u.getAllSchool()) {
        std::cout << "  School: " << s->name << "\n";
        for (const Faculty* f : s->faculties) {
            std::cout << "    Faculty " << f->facultyID << " " << f->facultyName
                      << " (school " << f->schoolName << ")"
                      << (f->hod ? ", HOD " + f->hod->facultyName : "") << " teaches";
            for (const Course* c : f->courses) std::cout << " " << c->courseCode;
            std::cout << "\n";
        }
        for (const Programme* p : s->programmes)
            std::cout << "    Programme " << p->programID << " " << p->ProgramName << "\n";
    }
    for (const Student* st : u.students)
        std::cout << "  Student " << st->stuID << " " << st->name << ", " << st->address
                  << " -> " << (st->programme ? st->programme->ProgramName : "not enrolled")
                  << "\n";
}

int main() {
    University ignou("IGNOU", "Maidan Garhi, New Delhi", 29572514);

    // Two schools
    School socis("SOCIS");
    School soms("SOMS");
    ignou.addSchool(socis);
    ignou.addSchool(soms);

    // Faculties, with a HOD link inside SOCIS
    Faculty f1("F01", "Dr. Sharma");
    Faculty f2("F02", "Dr. Verma");
    Faculty f3("F03", "Dr. Iyer");
    socis.addFaculty(f1);
    socis.addFaculty(f2);
    soms.addFaculty(f3);
    f2.hod = &f1;  // HOD 0..1

    // Programmes
    Programme mca("MCA", "Master of Computer Applications");
    Programme mba("MBA", "Master of Business Administration");
    socis.addProgramme(mca);
    soms.addProgramme(mba);

    // Courses and the catalogue operations
    Course c1("MCS-217", "Software Engineering");
    Course c2("MCSL-222", "OOAD and Web Technologies Lab");
    Course c3("MMPC-001", "Management Concepts");
    Course::addCourse(c1);
    Course::addCourse(c2);
    Course::addCourse(c3);
    c1.programmes.push_back(&mca);  // Course (1) <>-- (*) Programme
    c2.programmes.push_back(&mca);
    c3.programmes.push_back(&mba);
    f1.teaches(c1);
    f2.teaches(c2);
    f3.teaches(c3);

    // Students and registration
    Student s1(2401, "Asha", "Jaipur");
    Student s2(2402, "Ravi", "Pune");
    ignou.addStudent(s1);
    ignou.addStudent(s2);
    s1.enrol(mca);
    s2.enrol(mba);

    std::cout << "--- after setup ---\n";
    printUniversity(ignou);

    std::cout << "--- constraint check ---\n";
    s1.enrol(mba);  // refused: already in MCA

    std::cout << "--- lookups ---\n";
    std::cout << "getSchool(\"SOMS\") -> " << ignou.getSchool("SOMS")->name << "\n";
    std::cout << "getSchool(\"SOL\") -> "
              << (ignou.getSchool("SOL") ? "found" : "nullptr") << "\n";
    std::cout << "getStudent(2402) -> " << ignou.getStudent(2402)->name << "\n";
    std::cout << "getCoursebyCode(\"MCSL-222\") -> "
              << Course::getCoursebyCode("MCSL-222")->courseName << "\n";
    std::cout << "getCoursebyName(\"Management Concepts\") -> "
              << Course::getCoursebyName("Management Concepts")->courseCode << "\n";
    std::cout << "catalogue size: " << Course::catalogue.size() << "\n";

    std::cout << "--- removals ---\n";
    Course::removeCourse(c3);
    socis.removeFaculty(f2);
    soms.removeProgramme(mba);
    ignou.removeStudent(s2);
    ignou.removeSchool(soms);
    std::cout << "catalogue size: " << Course::catalogue.size()
              << ", f2.schoolName is \"" << f2.schoolName << "\""
              << ", mba.schools.size() = " << mba.schools.size() << "\n";
    printUniversity(ignou);
    return 0;
}

// student_registration.rs -- MCSL-222 Session 8, Q19
// Figure 1.15 (Student Registration) in Rust 2021, standard library only.
// Ownership: every object is an Rc<RefCell<T>>; an association end is an Rc clone (Weak for the School back link inside Programme, so the 1..* to 1..* link is not an Rc cycle).
// Build: rustc -O --edition 2021 student_registration.rs && ./student_registration
//
// Mapping used throughout:
//   class            -> struct + impl
//   attribute        -> pub field (same name as the figure)
//   operation        -> method or associated function (same name as the figure)
//   association end  -> Option<Rc<..>> for 1 / 0..1, Vec<Rc<..>> for * / 1..*
#![allow(non_snake_case)] // attribute and operation names are kept exactly as in the figure
#![allow(dead_code)] // Course.programmes is an association end main fills but never reads

use std::cell::RefCell;
use std::rc::{Rc, Weak};

type Ref<T> = Rc<RefCell<T>>;

fn new_ref<T>(x: T) -> Ref<T> {
    Rc::new(RefCell::new(x))
}

// Removes one link from an association vector. Every remove* operation uses it.
fn unlink<T>(v: &mut Vec<Ref<T>>, p: &Ref<T>) {
    v.retain(|x| !Rc::ptr_eq(x, p));
}

// ---------------------------------------------------------------- Course
struct Course {
    courseCode: String,
    courseName: String,
    programmes: Vec<Ref<Programme>>, // Course (1) <>-- (*) Programme, as drawn
}

thread_local! {
    // The four operations in the figure manage the list of courses, so they
    // work on one shared catalogue: the C++ static member is a thread-local static here.
    static CATALOGUE: RefCell<Vec<Ref<Course>>> = RefCell::new(Vec::new());
}

impl Course {
    fn new(code: &str, name: &str) -> Ref<Course> {
        new_ref(Course { courseCode: code.into(), courseName: name.into(), programmes: Vec::new() })
    }
    fn addCourse(c: &Ref<Course>) {
        CATALOGUE.with(|cat| cat.borrow_mut().push(Rc::clone(c)));
    }
    fn removeCourse(c: &Ref<Course>) {
        CATALOGUE.with(|cat| unlink(&mut cat.borrow_mut(), c));
    }
    fn getCoursebyName(name: &str) -> Option<Ref<Course>> {
        CATALOGUE.with(|cat| cat.borrow().iter().find(|c| c.borrow().courseName == name).cloned())
    }
    fn getCoursebyCode(code: &str) -> Option<Ref<Course>> {
        CATALOGUE.with(|cat| cat.borrow().iter().find(|c| c.borrow().courseCode == code).cloned())
    }
    fn catalogueSize() -> usize {
        CATALOGUE.with(|cat| cat.borrow().len())
    }
}

// ------------------------------------------------------------- Programme
struct Programme {
    programID: String,
    ProgramName: String,
    schools: Vec<Weak<RefCell<School>>>, // School (1..*) --- (1..*) Programme, back end
}

impl Programme {
    fn new(id: &str, name: &str) -> Ref<Programme> {
        new_ref(Programme { programID: id.into(), ProgramName: name.into(), schools: Vec::new() })
    }
}

// --------------------------------------------------------------- Faculty
struct Faculty {
    facultyID: String,
    facultyName: String,
    schoolName: String,
    hod: Option<Ref<Faculty>>, // HOD 0..1 (reflexive association)
    courses: Vec<Ref<Course>>, // Teaches: Faculty (1..*) --> Course
}

impl Faculty {
    fn new(id: &str, name: &str) -> Ref<Faculty> {
        new_ref(Faculty {
            facultyID: id.into(),
            facultyName: name.into(),
            schoolName: String::new(),
            hod: None,
            courses: Vec::new(),
        })
    }
    fn teaches(&mut self, c: &Ref<Course>) {
        self.courses.push(Rc::clone(c));
    }
}

// ---------------------------------------------------------------- School
struct School {
    name: String,
    faculties: Vec<Ref<Faculty>>,    // AssignTo: School (1) <>-- (1..*) Faculty
    programmes: Vec<Ref<Programme>>, // School (1..*) --- (1..*) Programme
}

impl School {
    fn new(n: &str) -> Ref<School> {
        new_ref(School { name: n.into(), faculties: Vec::new(), programmes: Vec::new() })
    }
    fn addFaculty(&mut self, f: &Ref<Faculty>) {
        self.faculties.push(Rc::clone(f));
        f.borrow_mut().schoolName = self.name.clone(); // the figure keeps the school name inside Faculty
    }
    fn removeFaculty(&mut self, f: &Ref<Faculty>) {
        unlink(&mut self.faculties, f);
        f.borrow_mut().schoolName.clear();
    }
    // Both ends are 1..*, so update both. The back link needs this school's Rc,
    // which a &self method cannot reach, so these two take it as a parameter.
    fn addProgramme(this: &Ref<School>, p: &Ref<Programme>) {
        this.borrow_mut().programmes.push(Rc::clone(p));
        p.borrow_mut().schools.push(Rc::downgrade(this));
    }
    fn removeProgramme(this: &Ref<School>, p: &Ref<Programme>) {
        unlink(&mut this.borrow_mut().programmes, p);
        let me = Rc::downgrade(this);
        p.borrow_mut().schools.retain(|w| !Weak::ptr_eq(w, &me));
    }
}

// --------------------------------------------------------------- Student
struct Student {
    stuID: i32,
    name: String,
    address: String,
    programme: Option<Ref<Programme>>, // enrol: Student --> Programme
}

impl Student {
    fn new(id: i32, n: &str, addr: &str) -> Ref<Student> {
        new_ref(Student { stuID: id, name: n.into(), address: addr.into(), programme: None })
    }
    // Constraint {one student per programme}: a registration binds a student
    // to exactly one programme, so a second enrol() is refused.
    fn enrol(&mut self, p: &Ref<Programme>) -> bool {
        if let Some(cur) = &self.programme {
            println!(
                "  refused: {} is already enrolled in {} (one student per programme)",
                self.name,
                cur.borrow().ProgramName
            );
            return false;
        }
        self.programme = Some(Rc::clone(p));
        true
    }
}

// ------------------------------------------------------------ University
struct University {
    name: String,
    address: String,
    phone: i32,
    schools: Vec<Ref<School>>,   // has: University (1) <>-- (1..*) School
    students: Vec<Ref<Student>>, // registration: University (1) <>-- (*) Student
}

impl University {
    fn new(n: &str, addr: &str, ph: i32) -> University {
        University { name: n.into(), address: addr.into(), phone: ph, schools: Vec::new(), students: Vec::new() }
    }
    fn addSchool(&mut self, s: &Ref<School>) {
        self.schools.push(Rc::clone(s));
    }
    fn removeSchool(&mut self, s: &Ref<School>) {
        unlink(&mut self.schools, s);
    }
    fn addStudent(&mut self, s: &Ref<Student>) {
        self.students.push(Rc::clone(s));
    }
    fn removeStudent(&mut self, s: &Ref<Student>) {
        unlink(&mut self.students, s);
    }
    fn getSchool(&self, n: &str) -> Option<Ref<School>> {
        self.schools.iter().find(|s| s.borrow().name == n).cloned()
    }
    fn getAllSchool(&self) -> &Vec<Ref<School>> {
        &self.schools
    }
    fn getStudent(&self, id: i32) -> Option<Ref<Student>> {
        self.students.iter().find(|s| s.borrow().stuID == id).cloned()
    }
}

// ------------------------------------------------------------------ main
fn print_university(u: &University) {
    println!("{}, {}, phone {}", u.name, u.address, u.phone);
    for s in u.getAllSchool() {
        let s = s.borrow();
        println!("  School: {}", s.name);
        for f in &s.faculties {
            let f = f.borrow();
            let hod = match &f.hod {
                Some(h) => format!(", HOD {}", h.borrow().facultyName),
                None => String::new(),
            };
            let mut line = format!(
                "    Faculty {} {} (school {}){} teaches",
                f.facultyID, f.facultyName, f.schoolName, hod
            );
            for c in &f.courses {
                line.push(' ');
                line.push_str(&c.borrow().courseCode);
            }
            println!("{}", line);
        }
        for p in &s.programmes {
            let p = p.borrow();
            println!("    Programme {} {}", p.programID, p.ProgramName);
        }
    }
    for st in &u.students {
        let st = st.borrow();
        let prog = match &st.programme {
            Some(p) => p.borrow().ProgramName.clone(),
            None => "not enrolled".to_string(),
        };
        println!("  Student {} {}, {} -> {}", st.stuID, st.name, st.address, prog);
    }
}

fn main() {
    let mut ignou = University::new("IGNOU", "Maidan Garhi, New Delhi", 29572514);

    // Two schools
    let socis = School::new("SOCIS");
    let soms = School::new("SOMS");
    ignou.addSchool(&socis);
    ignou.addSchool(&soms);

    // Faculties, with a HOD link inside SOCIS
    let f1 = Faculty::new("F01", "Dr. Sharma");
    let f2 = Faculty::new("F02", "Dr. Verma");
    let f3 = Faculty::new("F03", "Dr. Iyer");
    socis.borrow_mut().addFaculty(&f1);
    socis.borrow_mut().addFaculty(&f2);
    soms.borrow_mut().addFaculty(&f3);
    f2.borrow_mut().hod = Some(Rc::clone(&f1)); // HOD 0..1

    // Programmes
    let mca = Programme::new("MCA", "Master of Computer Applications");
    let mba = Programme::new("MBA", "Master of Business Administration");
    School::addProgramme(&socis, &mca);
    School::addProgramme(&soms, &mba);

    // Courses and the catalogue operations
    let c1 = Course::new("MCS-217", "Software Engineering");
    let c2 = Course::new("MCSL-222", "OOAD and Web Technologies Lab");
    let c3 = Course::new("MMPC-001", "Management Concepts");
    Course::addCourse(&c1);
    Course::addCourse(&c2);
    Course::addCourse(&c3);
    c1.borrow_mut().programmes.push(Rc::clone(&mca)); // Course (1) <>-- (*) Programme
    c2.borrow_mut().programmes.push(Rc::clone(&mca));
    c3.borrow_mut().programmes.push(Rc::clone(&mba));
    f1.borrow_mut().teaches(&c1);
    f2.borrow_mut().teaches(&c2);
    f3.borrow_mut().teaches(&c3);

    // Students and registration
    let s1 = Student::new(2401, "Asha", "Jaipur");
    let s2 = Student::new(2402, "Ravi", "Pune");
    ignou.addStudent(&s1);
    ignou.addStudent(&s2);
    s1.borrow_mut().enrol(&mca);
    s2.borrow_mut().enrol(&mba);

    println!("--- after setup ---");
    print_university(&ignou);

    println!("--- constraint check ---");
    s1.borrow_mut().enrol(&mba); // refused: already in MCA

    println!("--- lookups ---");
    let soms_found = ignou.getSchool("SOMS").unwrap();
    println!("getSchool(\"SOMS\") -> {}", soms_found.borrow().name);
    // "nullptr" is printed for a miss so the output matches the C++ version.
    println!("getSchool(\"SOL\") -> {}", if ignou.getSchool("SOL").is_some() { "found" } else { "nullptr" });
    let ravi = ignou.getStudent(2402).unwrap();
    println!("getStudent(2402) -> {}", ravi.borrow().name);
    let by_code = Course::getCoursebyCode("MCSL-222").unwrap();
    println!("getCoursebyCode(\"MCSL-222\") -> {}", by_code.borrow().courseName);
    let by_name = Course::getCoursebyName("Management Concepts").unwrap();
    println!("getCoursebyName(\"Management Concepts\") -> {}", by_name.borrow().courseCode);
    println!("catalogue size: {}", Course::catalogueSize());

    println!("--- removals ---");
    Course::removeCourse(&c3);
    socis.borrow_mut().removeFaculty(&f2);
    School::removeProgramme(&soms, &mba);
    ignou.removeStudent(&s2);
    ignou.removeSchool(&soms);
    println!(
        "catalogue size: {}, f2.schoolName is \"{}\", mba.schools.size() = {}",
        Course::catalogueSize(),
        f2.borrow().schoolName,
        mba.borrow().schools.len()
    );
    print_university(&ignou);
}

# student_registration.py -- MCSL-222 Session 8, Q19
# Figure 1.15 (Student Registration) in Python 3, standard library only.
# Run: python3 student_registration.py
#
# Mapping used throughout:
#   class            -> @dataclass
#   attribute        -> field (same name as the figure)
#   operation        -> method or @staticmethod (same name as the figure)
#   association end  -> object reference (or None) for 1 / 0..1, list for * / 1..*
# eq=False keeps identity comparison, so list.remove() unlinks that exact object
# and the two-way School/Programme links cannot recurse through a field-by-field ==.
from __future__ import annotations

from dataclasses import dataclass, field
from typing import ClassVar, Optional


# ---------------------------------------------------------------- Course
@dataclass(eq=False)
class Course:
    courseCode: str
    courseName: str
    programmes: list[Programme] = field(default_factory=list)  # Course (1) <>-- (*) Programme, as drawn

    # The four operations in the figure manage the list of courses, so they
    # work on one shared catalogue: a class attribute, the Python static member.
    catalogue: ClassVar[list[Course]] = []

    @staticmethod
    def addCourse(c: Course) -> None:
        Course.catalogue.append(c)

    @staticmethod
    def removeCourse(c: Course) -> None:
        Course.catalogue.remove(c)

    @staticmethod
    def getCoursebyName(name: str) -> Optional[Course]:
        return next((c for c in Course.catalogue if c.courseName == name), None)

    @staticmethod
    def getCoursebyCode(code: str) -> Optional[Course]:
        return next((c for c in Course.catalogue if c.courseCode == code), None)


# ------------------------------------------------------------- Programme
@dataclass(eq=False)
class Programme:
    programID: str
    ProgramName: str
    schools: list[School] = field(default_factory=list)  # School (1..*) --- (1..*) Programme


# --------------------------------------------------------------- Faculty
@dataclass(eq=False)
class Faculty:
    facultyID: str
    facultyName: str
    schoolName: str = ""
    hod: Optional[Faculty] = None                        # HOD 0..1 (reflexive association)
    courses: list[Course] = field(default_factory=list)  # Teaches: Faculty (1..*) --> Course

    def teaches(self, c: Course) -> None:
        self.courses.append(c)


# ---------------------------------------------------------------- School
@dataclass(eq=False)
class School:
    name: str
    faculties: list[Faculty] = field(default_factory=list)    # AssignTo: School (1) <>-- (1..*) Faculty
    programmes: list[Programme] = field(default_factory=list)  # School (1..*) --- (1..*) Programme

    def addFaculty(self, f: Faculty) -> None:
        self.faculties.append(f)
        f.schoolName = self.name  # the figure keeps the school name inside Faculty

    def removeFaculty(self, f: Faculty) -> None:
        self.faculties.remove(f)
        f.schoolName = ""

    def addProgramme(self, p: Programme) -> None:  # both ends are 1..*, so update both
        self.programmes.append(p)
        p.schools.append(self)

    def removeProgramme(self, p: Programme) -> None:
        self.programmes.remove(p)
        p.schools.remove(self)


# --------------------------------------------------------------- Student
@dataclass(eq=False)
class Student:
    stuID: int
    name: str
    address: str
    programme: Optional[Programme] = None  # enrol: Student --> Programme

    # Constraint {one student per programme}: a registration binds a student
    # to exactly one programme, so a second enrol() is refused.
    def enrol(self, p: Programme) -> bool:
        if self.programme is not None:
            print(f"  refused: {self.name} is already enrolled in "
                  f"{self.programme.ProgramName} (one student per programme)")
            return False
        self.programme = p
        return True


# ------------------------------------------------------------ University
@dataclass(eq=False)
class University:
    name: str
    address: str
    phone: int
    schools: list[School] = field(default_factory=list)    # has: University (1) <>-- (1..*) School
    students: list[Student] = field(default_factory=list)  # registration: University (1) <>-- (*) Student

    def addSchool(self, s: School) -> None:
        self.schools.append(s)

    def removeSchool(self, s: School) -> None:
        self.schools.remove(s)

    def addStudent(self, s: Student) -> None:
        self.students.append(s)

    def removeStudent(self, s: Student) -> None:
        self.students.remove(s)

    def getSchool(self, n: str) -> Optional[School]:
        return next((s for s in self.schools if s.name == n), None)

    def getAllSchool(self) -> list[School]:
        return self.schools

    def getStudent(self, id: int) -> Optional[Student]:
        return next((s for s in self.students if s.stuID == id), None)


# ------------------------------------------------------------------ main
def printUniversity(u: University) -> None:
    print(f"{u.name}, {u.address}, phone {u.phone}")
    for s in u.getAllSchool():
        print(f"  School: {s.name}")
        for f in s.faculties:
            hod = f", HOD {f.hod.facultyName}" if f.hod else ""
            codes = "".join(f" {c.courseCode}" for c in f.courses)
            print(f"    Faculty {f.facultyID} {f.facultyName} (school {f.schoolName}){hod} teaches{codes}")
        for p in s.programmes:
            print(f"    Programme {p.programID} {p.ProgramName}")
    for st in u.students:
        prog = st.programme.ProgramName if st.programme else "not enrolled"
        print(f"  Student {st.stuID} {st.name}, {st.address} -> {prog}")


def main() -> None:
    ignou = University("IGNOU", "Maidan Garhi, New Delhi", 29572514)

    # Two schools
    socis = School("SOCIS")
    soms = School("SOMS")
    ignou.addSchool(socis)
    ignou.addSchool(soms)

    # Faculties, with a HOD link inside SOCIS
    f1 = Faculty("F01", "Dr. Sharma")
    f2 = Faculty("F02", "Dr. Verma")
    f3 = Faculty("F03", "Dr. Iyer")
    socis.addFaculty(f1)
    socis.addFaculty(f2)
    soms.addFaculty(f3)
    f2.hod = f1  # HOD 0..1

    # Programmes
    mca = Programme("MCA", "Master of Computer Applications")
    mba = Programme("MBA", "Master of Business Administration")
    socis.addProgramme(mca)
    soms.addProgramme(mba)

    # Courses and the catalogue operations
    c1 = Course("MCS-217", "Software Engineering")
    c2 = Course("MCSL-222", "OOAD and Web Technologies Lab")
    c3 = Course("MMPC-001", "Management Concepts")
    Course.addCourse(c1)
    Course.addCourse(c2)
    Course.addCourse(c3)
    c1.programmes.append(mca)  # Course (1) <>-- (*) Programme
    c2.programmes.append(mca)
    c3.programmes.append(mba)
    f1.teaches(c1)
    f2.teaches(c2)
    f3.teaches(c3)

    # Students and registration
    s1 = Student(2401, "Asha", "Jaipur")
    s2 = Student(2402, "Ravi", "Pune")
    ignou.addStudent(s1)
    ignou.addStudent(s2)
    s1.enrol(mca)
    s2.enrol(mba)

    print("--- after setup ---")
    printUniversity(ignou)

    print("--- constraint check ---")
    s1.enrol(mba)  # refused: already in MCA

    print("--- lookups ---")
    print(f'getSchool("SOMS") -> {ignou.getSchool("SOMS").name}')
    # "nullptr" is printed for a miss so the output matches the C++ version.
    print(f'getSchool("SOL") -> {"found" if ignou.getSchool("SOL") else "nullptr"}')
    print(f"getStudent(2402) -> {ignou.getStudent(2402).name}")
    print(f'getCoursebyCode("MCSL-222") -> {Course.getCoursebyCode("MCSL-222").courseName}')
    print(f'getCoursebyName("Management Concepts") -> {Course.getCoursebyName("Management Concepts").courseCode}')
    print(f"catalogue size: {len(Course.catalogue)}")

    print("--- removals ---")
    Course.removeCourse(c3)
    socis.removeFaculty(f2)
    soms.removeProgramme(mba)
    ignou.removeStudent(s2)
    ignou.removeSchool(soms)
    print(f'catalogue size: {len(Course.catalogue)}, f2.schoolName is "{f2.schoolName}", '
          f"mba.schools.size() = {len(mba.schools)}")
    printUniversity(ignou)


if __name__ == "__main__":
    main()

// student_registration.ts -- MCSL-222 Session 8, Q19
// Figure 1.15 (Student Registration) in TypeScript, no dependencies.
// Run: node student_registration.ts   (Node 22.18 or later strips the types itself)
//
// Mapping used throughout:
//   class            -> class
//   attribute        -> typed field (same name as the figure), readonly when it never changes
//   operation        -> method or static method (same name as the figure)
//   association end  -> `T | null` for 1 / 0..1, `T[]` for * / 1..*
"use strict";

// Removes one link from an association array. Every remove* operation uses it.
function unlink<T>(arr: T[], p: T): void {
  const i = arr.indexOf(p);
  if (i >= 0) arr.splice(i, 1);
}

// Student and University both carry a name and a postal address.
interface Addressed {
  readonly name: string;
  readonly address: string;
}

// ---------------------------------------------------------------- Course
class Course {
  // The four operations in the figure manage the list of courses, so they
  // work on one shared catalogue: a static field plus static methods.
  static readonly catalogue: Course[] = [];

  readonly courseCode: string;
  readonly courseName: string;
  readonly programmes: Programme[] = []; // Course (1) <>-- (*) Programme, as drawn

  constructor(code: string, name: string) {
    this.courseCode = code;
    this.courseName = name;
  }

  static addCourse(c: Course): void { Course.catalogue.push(c); }
  static removeCourse(c: Course): void { unlink(Course.catalogue, c); }
  static getCoursebyName(name: string): Course | null { return Course.catalogue.find((c) => c.courseName === name) ?? null; }
  static getCoursebyCode(code: string): Course | null { return Course.catalogue.find((c) => c.courseCode === code) ?? null; }
}

// ------------------------------------------------------------- Programme
class Programme {
  readonly programID: string;
  readonly ProgramName: string;
  readonly schools: School[] = []; // School (1..*) --- (1..*) Programme

  constructor(id: string, name: string) {
    this.programID = id;
    this.ProgramName = name;
  }
}

// --------------------------------------------------------------- Faculty
class Faculty {
  readonly facultyID: string;
  readonly facultyName: string;
  schoolName: string = "";
  hod: Faculty | null = null;      // HOD 0..1 (reflexive association)
  readonly courses: Course[] = []; // Teaches: Faculty (1..*) --> Course

  constructor(id: string, name: string) {
    this.facultyID = id;
    this.facultyName = name;
  }

  teaches(c: Course): void { this.courses.push(c); }
}

// ---------------------------------------------------------------- School
class School {
  readonly name: string;
  readonly faculties: Faculty[] = [];  // AssignTo: School (1) <>-- (1..*) Faculty
  readonly programmes: Programme[] = []; // School (1..*) --- (1..*) Programme

  constructor(n: string) {
    this.name = n;
  }

  addFaculty(f: Faculty): void {
    this.faculties.push(f);
    f.schoolName = this.name; // the figure keeps the school name inside Faculty
  }
  removeFaculty(f: Faculty): void {
    unlink(this.faculties, f);
    f.schoolName = "";
  }
  addProgramme(p: Programme): void { // both ends are 1..*, so update both
    this.programmes.push(p);
    p.schools.push(this);
  }
  removeProgramme(p: Programme): void {
    unlink(this.programmes, p);
    unlink(p.schools, this);
  }
}

// --------------------------------------------------------------- Student
class Student implements Addressed {
  readonly stuID: number;
  readonly name: string;
  readonly address: string;
  programme: Programme | null = null; // enrol: Student --> Programme

  constructor(id: number, n: string, addr: string) {
    this.stuID = id;
    this.name = n;
    this.address = addr;
  }

  // Constraint {one student per programme}: a registration binds a student
  // to exactly one programme, so a second enrol() is refused.
  enrol(p: Programme): boolean {
    if (this.programme !== null) {
      console.log(`  refused: ${this.name} is already enrolled in ${this.programme.ProgramName} (one student per programme)`);
      return false;
    }
    this.programme = p;
    return true;
  }
}

// ------------------------------------------------------------ University
class University implements Addressed {
  readonly name: string;
  readonly address: string;
  readonly phone: number;
  readonly schools: School[] = [];   // has: University (1) <>-- (1..*) School
  readonly students: Student[] = []; // registration: University (1) <>-- (*) Student

  constructor(n: string, addr: string, ph: number) {
    this.name = n;
    this.address = addr;
    this.phone = ph;
  }

  addSchool(s: School): void { this.schools.push(s); }
  removeSchool(s: School): void { unlink(this.schools, s); }
  addStudent(s: Student): void { this.students.push(s); }
  removeStudent(s: Student): void { unlink(this.students, s); }
  getSchool(n: string): School | null { return this.schools.find((s) => s.name === n) ?? null; }
  getAllSchool(): School[] { return this.schools; }
  getStudent(id: number): Student | null { return this.students.find((s) => s.stuID === id) ?? null; }
}

// ------------------------------------------------------------------ main
function where(x: Addressed): string { return `${x.name}, ${x.address}`; }

function printUniversity(u: University): void {
  console.log(`${where(u)}, phone ${u.phone}`);
  for (const s of u.getAllSchool()) {
    console.log(`  School: ${s.name}`);
    for (const f of s.faculties) {
      const hod = f.hod ? `, HOD ${f.hod.facultyName}` : "";
      const codes = f.courses.map((c) => ` ${c.courseCode}`).join("");
      console.log(`    Faculty ${f.facultyID} ${f.facultyName} (school ${f.schoolName})${hod} teaches${codes}`);
    }
    for (const p of s.programmes) console.log(`    Programme ${p.programID} ${p.ProgramName}`);
  }
  for (const st of u.students) {
    const prog = st.programme ? st.programme.ProgramName : "not enrolled";
    console.log(`  Student ${st.stuID} ${where(st)} -> ${prog}`);
  }
}

function main(): void {
  const ignou = new University("IGNOU", "Maidan Garhi, New Delhi", 29572514);

  // Two schools
  const socis = new School("SOCIS");
  const soms = new School("SOMS");
  ignou.addSchool(socis);
  ignou.addSchool(soms);

  // Faculties, with a HOD link inside SOCIS
  const f1 = new Faculty("F01", "Dr. Sharma");
  const f2 = new Faculty("F02", "Dr. Verma");
  const f3 = new Faculty("F03", "Dr. Iyer");
  socis.addFaculty(f1);
  socis.addFaculty(f2);
  soms.addFaculty(f3);
  f2.hod = f1; // HOD 0..1

  // Programmes
  const mca = new Programme("MCA", "Master of Computer Applications");
  const mba = new Programme("MBA", "Master of Business Administration");
  socis.addProgramme(mca);
  soms.addProgramme(mba);

  // Courses and the catalogue operations
  const c1 = new Course("MCS-217", "Software Engineering");
  const c2 = new Course("MCSL-222", "OOAD and Web Technologies Lab");
  const c3 = new Course("MMPC-001", "Management Concepts");
  Course.addCourse(c1);
  Course.addCourse(c2);
  Course.addCourse(c3);
  c1.programmes.push(mca); // Course (1) <>-- (*) Programme
  c2.programmes.push(mca);
  c3.programmes.push(mba);
  f1.teaches(c1);
  f2.teaches(c2);
  f3.teaches(c3);

  // Students and registration
  const s1 = new Student(2401, "Asha", "Jaipur");
  const s2 = new Student(2402, "Ravi", "Pune");
  ignou.addStudent(s1);
  ignou.addStudent(s2);
  s1.enrol(mca);
  s2.enrol(mba);

  console.log("--- after setup ---");
  printUniversity(ignou);

  console.log("--- constraint check ---");
  s1.enrol(mba); // refused: already in MCA

  console.log("--- lookups ---");
  // The lookups return `T | null`; `!` tells the checker these hits exist.
  console.log(`getSchool("SOMS") -> ${ignou.getSchool("SOMS")!.name}`);
  // "nullptr" is printed for a miss so the output matches the C++ version.
  console.log(`getSchool("SOL") -> ${ignou.getSchool("SOL") ? "found" : "nullptr"}`);
  console.log(`getStudent(2402) -> ${ignou.getStudent(2402)!.name}`);
  console.log(`getCoursebyCode("MCSL-222") -> ${Course.getCoursebyCode("MCSL-222")!.courseName}`);
  console.log(`getCoursebyName("Management Concepts") -> ${Course.getCoursebyName("Management Concepts")!.courseCode}`);
  console.log(`catalogue size: ${Course.catalogue.length}`);

  console.log("--- removals ---");
  Course.removeCourse(c3);
  socis.removeFaculty(f2);
  soms.removeProgramme(mba);
  ignou.removeStudent(s2);
  ignou.removeSchool(soms);
  console.log(`catalogue size: ${Course.catalogue.length}, f2.schoolName is "${f2.schoolName}", mba.schools.size() = ${mba.schools.length}`);
  printUniversity(ignou);
}

main();

// customer_order.cpp -- MCSL-222 Session 8, Q20
// Figure 1.18 (Customer places Order, Order contains Product, OrderLine
// association class) implemented in C++17.
// Build: clang++ -std=c++17 -Wall -Wextra -o customer_order customer_order.cpp

#include <iomanip>
#include <iostream>
#include <string>
#include <vector>

class Order;
class Product;

// ------------------------------------------------------------- Product
class Product {
public:
    std::string P_Name;
    std::string P_Manufacturer;
    int Product_ID;
    double UnitPrice;
    int Units_in_Stock;

    Product(std::string name, std::string maker, int id, double price, int stock)
        : P_Name(std::move(name)), P_Manufacturer(std::move(maker)), Product_ID(id),
          UnitPrice(price), Units_in_Stock(stock) {}
};

// ----------------------------------------------------------- OrderLine
// The association class: one object per (Order, Product) pair, holding the
// attributes that belong to the link and not to either end.
class OrderLine {
public:
    Order* order;
    Product* product;
    int Quantity;
    double UnitSalePrice;

    double lineTotal() const { return Quantity * UnitSalePrice; }
};

// --------------------------------------------------------------- Order
class Order {
public:
    std::string OrderDate;
    std::string ProductSoldBy;
    double ProductOrderCost = 0.0;
    class Customer* customer = nullptr;  // back link of "places" (1..1)
    std::vector<OrderLine> lines;        // contains: Order (0..*) --> (1..*) Product

    Order(std::string date, std::string soldBy)
        : OrderDate(std::move(date)), ProductSoldBy(std::move(soldBy)) {}

    // Adds one Product to this Order through an OrderLine.
    bool contains(Product& p, int qty, double salePrice) {
        if (qty <= 0 || qty > p.Units_in_Stock) {
            std::cout << "  refused: only " << p.Units_in_Stock << " x " << p.P_Name
                      << " in stock, asked for " << qty << "\n";
            return false;
        }
        lines.push_back(OrderLine{this, &p, qty, salePrice});
        p.Units_in_Stock -= qty;
        ProductOrderCost += qty * salePrice;
        return true;
    }
};

// ------------------------------------------------------------ Customer
class Customer {
public:
    std::string C_Name;
    std::string C_Phone;
    std::string C_Address;
    std::string C_Pin;
    std::string C_Email;
    std::vector<Order*> orders;  // places: Customer (1..1) --> (0..*) Order

    Customer(std::string name, std::string phone, std::string addr, std::string pin,
             std::string email)
        : C_Name(std::move(name)), C_Phone(std::move(phone)), C_Address(std::move(addr)),
          C_Pin(std::move(pin)), C_Email(std::move(email)) {}

    void places(Order& o) {
        orders.push_back(&o);
        o.customer = this;
    }
};

// ---------------------------------------------------------------- main
static void printOrder(const Order& o) {
    std::cout << "Order dated " << o.OrderDate << " sold by " << o.ProductSoldBy
              << " for " << (o.customer ? o.customer->C_Name : "nobody") << "\n";
    for (const OrderLine& l : o.lines)
        std::cout << "  " << std::left << std::setw(12) << l.product->P_Name
                  << std::right << std::setw(3) << l.Quantity << " x "
                  << std::fixed << std::setprecision(2) << std::setw(9) << l.UnitSalePrice
                  << " = " << std::setw(9) << l.lineTotal() << "\n";
    std::cout << "  ProductOrderCost = " << std::fixed << std::setprecision(2)
              << o.ProductOrderCost << "\n";
}

int main() {
    Product pen("Pen", "Cello", 101, 10.00, 500);
    Product notebook("Notebook", "Classmate", 102, 45.00, 40);
    Product stapler("Stapler", "Kangaro", 103, 120.00, 3);

    Customer asha("Asha", "9876543210", "12 MG Road, Jaipur", "302001", "asha@example.com");

    Order o1("2026-09-01", "Store counter");
    Order o2("2026-09-15", "Online");
    asha.places(o1);
    asha.places(o2);

    o1.contains(pen, 20, 9.50);       // discounted sale price
    o1.contains(notebook, 5, 45.00);
    o2.contains(stapler, 2, 115.00);
    o2.contains(stapler, 2, 115.00);  // refused: only 1 left

    for (const Order* o : asha.orders) printOrder(*o);

    std::cout << "Stock left: pen " << pen.Units_in_Stock << ", notebook "
              << notebook.Units_in_Stock << ", stapler " << stapler.Units_in_Stock << "\n";
    std::cout << asha.C_Name << " has placed " << asha.orders.size() << " orders\n";
    return 0;
}

// customer_order.rs -- MCSL-222 Session 8, Q20
// Figure 1.18 (Customer places Order, Order contains Product, OrderLine
// association class) in Rust 2021, standard library only.
// Ownership: Rc<RefCell<T>> for Product, Order and Customer; Customer holds Rc links to its orders and Order holds a Weak back link to its customer (1..1), so the two-way "places" link is not an Rc cycle.
// Build: rustc -O --edition 2021 customer_order.rs && ./customer_order
#![allow(non_snake_case)] // attribute names are kept exactly as in the figure
#![allow(dead_code)] // attributes the figure lists (phone, e-mail, manufacturer, ...) that main never reads

use std::cell::RefCell;
use std::rc::{Rc, Weak};

type Ref<T> = Rc<RefCell<T>>;

fn new_ref<T>(x: T) -> Ref<T> {
    Rc::new(RefCell::new(x))
}

// ------------------------------------------------------------- Product
struct Product {
    P_Name: String,
    P_Manufacturer: String,
    Product_ID: i32,
    UnitPrice: f64,
    Units_in_Stock: i32,
}

impl Product {
    fn new(name: &str, maker: &str, id: i32, price: f64, stock: i32) -> Ref<Product> {
        new_ref(Product {
            P_Name: name.into(),
            P_Manufacturer: maker.into(),
            Product_ID: id,
            UnitPrice: price,
            Units_in_Stock: stock,
        })
    }
}

// ----------------------------------------------------------- OrderLine
// The association class: one object per (Order, Product) pair, holding the
// attributes that belong to the link and not to either end.
struct OrderLine {
    order: Weak<RefCell<Order>>,
    product: Ref<Product>,
    Quantity: i32,
    UnitSalePrice: f64,
}

impl OrderLine {
    fn lineTotal(&self) -> f64 {
        f64::from(self.Quantity) * self.UnitSalePrice
    }
}

// --------------------------------------------------------------- Order
struct Order {
    OrderDate: String,
    ProductSoldBy: String,
    ProductOrderCost: f64,
    customer: Option<Weak<RefCell<Customer>>>, // back link of "places" (1..1)
    lines: Vec<OrderLine>,                     // contains: Order (0..*) --> (1..*) Product
}

impl Order {
    fn new(date: &str, sold_by: &str) -> Ref<Order> {
        new_ref(Order {
            OrderDate: date.into(),
            ProductSoldBy: sold_by.into(),
            ProductOrderCost: 0.0,
            customer: None,
            lines: Vec::new(),
        })
    }

    // Adds one Product to this Order through an OrderLine. Takes the order's
    // Rc so the line can keep a back link to it.
    fn contains(this: &Ref<Order>, p: &Ref<Product>, qty: i32, salePrice: f64) -> bool {
        let stock = p.borrow().Units_in_Stock;
        if qty <= 0 || qty > stock {
            println!("  refused: only {} x {} in stock, asked for {}", stock, p.borrow().P_Name, qty);
            return false;
        }
        let mut o = this.borrow_mut();
        o.lines.push(OrderLine {
            order: Rc::downgrade(this),
            product: Rc::clone(p),
            Quantity: qty,
            UnitSalePrice: salePrice,
        });
        p.borrow_mut().Units_in_Stock -= qty;
        o.ProductOrderCost += f64::from(qty) * salePrice;
        true
    }
}

// ------------------------------------------------------------ Customer
struct Customer {
    C_Name: String,
    C_Phone: String,
    C_Address: String,
    C_Pin: String,
    C_Email: String,
    orders: Vec<Ref<Order>>, // places: Customer (1..1) --> (0..*) Order
}

impl Customer {
    fn new(name: &str, phone: &str, addr: &str, pin: &str, email: &str) -> Ref<Customer> {
        new_ref(Customer {
            C_Name: name.into(),
            C_Phone: phone.into(),
            C_Address: addr.into(),
            C_Pin: pin.into(),
            C_Email: email.into(),
            orders: Vec::new(),
        })
    }

    fn places(this: &Ref<Customer>, o: &Ref<Order>) {
        this.borrow_mut().orders.push(Rc::clone(o));
        o.borrow_mut().customer = Some(Rc::downgrade(this));
    }
}

// ---------------------------------------------------------------- main
fn print_order(o: &Order) {
    let who = o
        .customer
        .as_ref()
        .and_then(Weak::upgrade)
        .map(|c| c.borrow().C_Name.clone())
        .unwrap_or_else(|| "nobody".to_string());
    println!("Order dated {} sold by {} for {}", o.OrderDate, o.ProductSoldBy, who);
    for l in &o.lines {
        println!(
            "  {:<12}{:>3} x {:>9.2} = {:>9.2}",
            l.product.borrow().P_Name,
            l.Quantity,
            l.UnitSalePrice,
            l.lineTotal()
        );
    }
    println!("  ProductOrderCost = {:.2}", o.ProductOrderCost);
}

fn main() {
    let pen = Product::new("Pen", "Cello", 101, 10.00, 500);
    let notebook = Product::new("Notebook", "Classmate", 102, 45.00, 40);
    let stapler = Product::new("Stapler", "Kangaro", 103, 120.00, 3);

    let asha = Customer::new("Asha", "9876543210", "12 MG Road, Jaipur", "302001", "asha@example.com");

    let o1 = Order::new("2026-09-01", "Store counter");
    let o2 = Order::new("2026-09-15", "Online");
    Customer::places(&asha, &o1);
    Customer::places(&asha, &o2);

    Order::contains(&o1, &pen, 20, 9.50); // discounted sale price
    Order::contains(&o1, &notebook, 5, 45.00);
    Order::contains(&o2, &stapler, 2, 115.00);
    Order::contains(&o2, &stapler, 2, 115.00); // refused: only 1 left

    for o in &asha.borrow().orders {
        print_order(&o.borrow());
    }

    println!(
        "Stock left: pen {}, notebook {}, stapler {}",
        pen.borrow().Units_in_Stock,
        notebook.borrow().Units_in_Stock,
        stapler.borrow().Units_in_Stock
    );
    println!("{} has placed {} orders", asha.borrow().C_Name, asha.borrow().orders.len());
}