Class Relationships and UML

package main

import (
	"fmt"
	"strings"
)

// Teacher and Student live on their own; batches only point at them.
type Teacher struct {
	Name    string
	batches []*Batch
}

type Student struct {
	Name    string
	batches []*Batch
}

// Session is owned by its batch (composition): it is created inside the batch and
// has no meaning outside it.
type Session struct{ Topic string }

type Batch struct {
	Name     string
	teacher  *Teacher   // aggregation: shared, outlives the batch
	sessions []Session  // composition: owned, dies with the batch
	students []*Student // association: many-to-many, both sides know
}

// School is where batches are created and cancelled.
type School struct{ batches []*Batch }

func (s *School) Open(name string, t *Teacher, topics ...string) *Batch {
	b := &Batch{Name: name, teacher: t}
	for _, topic := range topics {
		b.sessions = append(b.sessions, Session{Topic: topic})
	}
	t.batches = append(t.batches, b)
	s.batches = append(s.batches, b)
	return b
}

func (b *Batch) Enroll(st *Student) {
	b.students = append(b.students, st)
	st.batches = append(st.batches, b)
}

// Cancel removes the batch everywhere it is referenced. Its sessions need no clean-up:
// nothing else holds them.
func (s *School) Cancel(b *Batch) {
	s.batches = without(s.batches, b)
	b.teacher.batches = without(b.teacher.batches, b)
	for _, st := range b.students {
		st.batches = without(st.batches, b)
	}
}

func without(list []*Batch, b *Batch) []*Batch {
	out := []*Batch{}
	for _, x := range list {
		if x != b {
			out = append(out, x)
		}
	}
	return out
}

func names(list []*Batch) string {
	if len(list) == 0 {
		return "(none)"
	}
	n := []string{}
	for _, b := range list {
		n = append(n, b.Name)
	}
	return strings.Join(n, ", ")
}

// PrintSummary only uses a batch for a moment (dependency): it keeps no reference.
func PrintSummary(b *Batch) {
	st := []string{}
	for _, s := range b.students {
		st = append(st, s.Name)
	}
	fmt.Printf("%s: teacher %s, %d sessions, students %s\n",
		b.Name, b.teacher.Name, len(b.sessions), strings.Join(st, ", "))
}

func main() {
	school := &School{}
	karim := &Teacher{Name: "Karim"}
	rahim, nadia := &Student{Name: "Rahim"}, &Student{Name: "Nadia"}

	physics := school.Open("HSC-Physics", karim, "Vectors", "Motion", "Waves")
	math := school.Open("HSC-Math", karim, "Matrices", "Calculus")
	physics.Enroll(rahim)
	physics.Enroll(nadia)
	math.Enroll(rahim)

	PrintSummary(physics)
	PrintSummary(math)
	fmt.Println("Rahim's batches:", names(rahim.batches))

	fmt.Printf("cancel %s: its %d sessions go with it\n", physics.Name, len(physics.sessions))
	school.Cancel(physics)
	fmt.Println("Karim still exists, teaches:", names(karim.batches))
	fmt.Println("Rahim still exists, batches:", names(rahim.batches))
	fmt.Println("Nadia still exists, batches:", names(nadia.batches))
	fmt.Println("open batches:", names(school.batches))
}

from __future__ import annotations

from dataclasses import dataclass, field


@dataclass(eq=False)
class Teacher:
    """Lives on its own; batches only point at it."""
    name: str
    batches: list[Batch] = field(default_factory=list)


@dataclass(eq=False)
class Student:
    name: str
    batches: list[Batch] = field(default_factory=list)


@dataclass(frozen=True)
class Session:
    """Owned by its batch (composition): no meaning outside it."""
    topic: str


@dataclass(eq=False)
class Batch:
    name: str
    teacher: Teacher                                         # aggregation: shared, outlives the batch
    sessions: list[Session] = field(default_factory=list)    # composition: owned, dies with the batch
    students: list[Student] = field(default_factory=list)    # association: many-to-many

    def enroll(self, st: Student) -> None:
        self.students.append(st)
        st.batches.append(self)


class School:
    def __init__(self) -> None:
        self.batches: list[Batch] = []

    def open(self, name: str, t: Teacher, *topics: str) -> Batch:
        b = Batch(name, t, [Session(x) for x in topics])
        t.batches.append(b)
        self.batches.append(b)
        return b

    def cancel(self, b: Batch) -> None:
        """Remove the batch everywhere it is referenced. Its sessions need no clean-up."""
        self.batches.remove(b)
        b.teacher.batches.remove(b)
        for st in b.students:
            st.batches.remove(b)


def names(batches: list[Batch]) -> str:
    return ", ".join(b.name for b in batches) or "(none)"


def print_summary(b: Batch) -> None:
    """Uses a batch only for a moment (dependency): keeps no reference."""
    students = ", ".join(s.name for s in b.students)
    print(f"{b.name}: teacher {b.teacher.name}, {len(b.sessions)} sessions, students {students}")


school = School()
karim = Teacher("Karim")
rahim, nadia = Student("Rahim"), Student("Nadia")

physics = school.open("HSC-Physics", karim, "Vectors", "Motion", "Waves")
math = school.open("HSC-Math", karim, "Matrices", "Calculus")
physics.enroll(rahim)
physics.enroll(nadia)
math.enroll(rahim)

print_summary(physics)
print_summary(math)
print("Rahim's batches:", names(rahim.batches))

print(f"cancel {physics.name}: its {len(physics.sessions)} sessions go with it")
school.cancel(physics)
print("Karim still exists, teaches:", names(karim.batches))
print("Rahim still exists, batches:", names(rahim.batches))
print("Nadia still exists, batches:", names(nadia.batches))
print("open batches:", names(school.batches))

// Teacher and Student live on their own; batches only point at them.
class Teacher {
  readonly name: string;
  batches: Batch[] = [];
  constructor(name: string) {
    this.name = name;
  }
}

class Student {
  readonly name: string;
  batches: Batch[] = [];
  constructor(name: string) {
    this.name = name;
  }
}

// Owned by its batch (composition): no meaning outside it.
interface Session {
  readonly topic: string;
}

class Batch {
  readonly name: string;
  readonly teacher: Teacher; // aggregation: shared, outlives the batch
  readonly sessions: Session[]; // composition: owned, dies with the batch
  readonly students: Student[] = []; // association: many-to-many
  constructor(name: string, teacher: Teacher, topics: string[]) {
    this.name = name;
    this.teacher = teacher;
    this.sessions = topics.map((topic) => ({ topic }));
  }
  enroll(st: Student): void {
    this.students.push(st);
    st.batches.push(this);
  }
}

const without = (list: Batch[], b: Batch) => list.filter((x) => x !== b);

class School {
  batches: Batch[] = [];
  open(name: string, t: Teacher, ...topics: string[]): Batch {
    const b = new Batch(name, t, topics);
    t.batches.push(b);
    this.batches.push(b);
    return b;
  }
  // Remove the batch everywhere it is referenced. Its sessions need no clean-up.
  cancel(b: Batch): void {
    this.batches = without(this.batches, b);
    b.teacher.batches = without(b.teacher.batches, b);
    for (const st of b.students) st.batches = without(st.batches, b);
  }
}

const names = (list: Batch[]) => list.map((b) => b.name).join(", ") || "(none)";

// Uses a batch only for a moment (dependency): keeps no reference.
function printSummary(b: Batch): void {
  const students = b.students.map((s) => s.name).join(", ");
  console.log(`${b.name}: teacher ${b.teacher.name}, ${b.sessions.length} sessions, students ${students}`);
}

const school = new School();
const karim = new Teacher("Karim");
const rahim = new Student("Rahim"), nadia = new Student("Nadia");

const physics = school.open("HSC-Physics", karim, "Vectors", "Motion", "Waves");
const math = school.open("HSC-Math", karim, "Matrices", "Calculus");
physics.enroll(rahim);
physics.enroll(nadia);
math.enroll(rahim);

printSummary(physics);
printSummary(math);
console.log("Rahim's batches:", names(rahim.batches));

console.log(`cancel ${physics.name}: its ${physics.sessions.length} sessions go with it`);
school.cancel(physics);
console.log("Karim still exists, teaches:", names(karim.batches));
console.log("Rahim still exists, batches:", names(rahim.batches));
console.log("Nadia still exists, batches:", names(nadia.batches));
console.log("open batches:", names(school.batches));

// School owns everyone. Relationships are stored as IDs (indexes), which is how Rust
// models shared, many-to-many links without fighting the borrow checker.
type Id = usize;

struct Teacher { name: String }
struct Student { name: String }

// Owned by its batch (composition): a plain value inside the batch.
struct Session { _topic: String }

struct Batch {
    name: String,
    teacher: Id,            // aggregation: shared, outlives the batch
    sessions: Vec<Session>, // composition: owned, dropped with the batch
    students: Vec<Id>,      // association: many-to-many (Student side is looked up below)
}

struct School { teachers: Vec<Teacher>, students: Vec<Student>, batches: Vec<Option<Batch>> }

impl School {
    fn open(&mut self, name: &str, t: Id, topics: &[&str]) -> Id {
        let sessions = topics.iter().map(|x| Session { _topic: x.to_string() }).collect();
        self.batches.push(Some(Batch { name: name.into(), teacher: t, sessions, students: vec![] }));
        self.batches.len() - 1
    }
    fn enroll(&mut self, b: Id, st: Id) { self.batches[b].as_mut().unwrap().students.push(st); }

    // Cancelling drops the Batch value, and its sessions are dropped with it.
    fn cancel(&mut self, b: Id) { self.batches[b] = None; }

    fn open_batches(&self) -> impl Iterator<Item = &Batch> { self.batches.iter().flatten() }
    fn names<'a>(&self, it: impl Iterator<Item = &'a Batch>) -> String {
        let v: Vec<&str> = it.map(|b| b.name.as_str()).collect();
        if v.is_empty() { "(none)".into() } else { v.join(", ") }
    }
    fn of_teacher(&self, t: Id) -> String { self.names(self.open_batches().filter(|b| b.teacher == t)) }
    fn of_student(&self, s: Id) -> String { self.names(self.open_batches().filter(|b| b.students.contains(&s))) }
}

// Uses a batch only for a moment (dependency): borrows it, keeps nothing.
fn print_summary(school: &School, b: &Batch) {
    let st: Vec<&str> = b.students.iter().map(|&s| school.students[s].name.as_str()).collect();
    println!("{}: teacher {}, {} sessions, students {}",
             b.name, school.teachers[b.teacher].name, b.sessions.len(), st.join(", "));
}

fn main() {
    let mut school = School {
        teachers: vec![Teacher { name: "Karim".into() }],
        students: vec![Student { name: "Rahim".into() }, Student { name: "Nadia".into() }],
        batches: vec![],
    };
    let (karim, rahim, nadia) = (0, 0, 1);

    let physics = school.open("HSC-Physics", karim, &["Vectors", "Motion", "Waves"]);
    let math = school.open("HSC-Math", karim, &["Matrices", "Calculus"]);
    school.enroll(physics, rahim);
    school.enroll(physics, nadia);
    school.enroll(math, rahim);

    print_summary(&school, school.batches[physics].as_ref().unwrap());
    print_summary(&school, school.batches[math].as_ref().unwrap());
    println!("Rahim's batches: {}", school.of_student(rahim));

    let p = school.batches[physics].as_ref().unwrap();
    println!("cancel {}: its {} sessions go with it", p.name, p.sessions.len());
    school.cancel(physics);
    println!("Karim still exists, teaches: {}", school.of_teacher(karim));
    println!("Rahim still exists, batches: {}", school.of_student(rahim));
    println!("Nadia still exists, batches: {}", school.of_student(nadia));
    println!("open batches: {}", school.names(school.open_batches()));
}

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    // Teacher and Student live on their own; batches only point at them.
    static final class Teacher {
        final String name;
        final List<Batch> batches = new ArrayList<>();
        Teacher(String name) { this.name = name; }
    }

    static final class Student {
        final String name;
        final List<Batch> batches = new ArrayList<>();
        Student(String name) { this.name = name; }
    }

    // Owned by its batch (composition): no meaning outside it.
    record Session(String topic) {}

    static final class Batch {
        final String name;
        final Teacher teacher;                             // aggregation: shared, outlives the batch
        final List<Session> sessions = new ArrayList<>();  // composition: owned, dies with the batch
        final List<Student> students = new ArrayList<>();  // association: many-to-many

        Batch(String name, Teacher teacher, String... topics) {
            this.name = name;
            this.teacher = teacher;
            for (String t : topics) sessions.add(new Session(t));
        }

        void enroll(Student st) {
            students.add(st);
            st.batches.add(this);
        }
    }

    static final class School {
        final List<Batch> batches = new ArrayList<>();

        Batch open(String name, Teacher t, String... topics) {
            Batch b = new Batch(name, t, topics);
            t.batches.add(b);
            batches.add(b);
            return b;
        }

        // Remove the batch everywhere it is referenced. Its sessions need no clean-up.
        void cancel(Batch b) {
            batches.remove(b);
            b.teacher.batches.remove(b);
            for (Student st : b.students) st.batches.remove(b);
        }
    }

    static String names(List<Batch> list) {
        return list.isEmpty() ? "(none)" : list.stream().map(b -> b.name).collect(Collectors.joining(", "));
    }

    // Uses a batch only for a moment (dependency): keeps no reference.
    static void printSummary(Batch b) {
        String st = b.students.stream().map(s -> s.name).collect(Collectors.joining(", "));
        System.out.printf("%s: teacher %s, %d sessions, students %s%n", b.name, b.teacher.name, b.sessions.size(), st);
    }

    public static void main(String[] args) {
        School school = new School();
        Teacher karim = new Teacher("Karim");
        Student rahim = new Student("Rahim"), nadia = new Student("Nadia");

        Batch physics = school.open("HSC-Physics", karim, "Vectors", "Motion", "Waves");
        Batch math = school.open("HSC-Math", karim, "Matrices", "Calculus");
        physics.enroll(rahim);
        physics.enroll(nadia);
        math.enroll(rahim);

        printSummary(physics);
        printSummary(math);
        System.out.println("Rahim's batches: " + names(rahim.batches));

        System.out.printf("cancel %s: its %d sessions go with it%n", physics.name, physics.sessions.size());
        school.cancel(physics);
        System.out.println("Karim still exists, teaches: " + names(karim.batches));
        System.out.println("Rahim still exists, batches: " + names(rahim.batches));
        System.out.println("Nadia still exists, batches: " + names(nadia.batches));
        System.out.println("open batches: " + names(school.batches));
    }
}

#include <algorithm>
#include <cstdio>
#include <memory>
#include <string>
#include <vector>

struct Batch;

// Teacher and Student live on their own; batches only point at them (raw, non-owning pointers).
struct Teacher {
    std::string name;
    std::vector<Batch*> batches;
};

struct Student {
    std::string name;
    std::vector<Batch*> batches;
};

// Owned by its batch (composition): stored by value, destroyed with the batch.
struct Session {
    std::string topic;
};

struct Batch {
    std::string name;
    Teacher* teacher;               // aggregation: shared, outlives the batch
    std::vector<Session> sessions;  // composition: owned, dies with the batch
    std::vector<Student*> students; // association: many-to-many

    void enroll(Student& st) {
        students.push_back(&st);
        st.batches.push_back(this);
    }
};

void erase(std::vector<Batch*>& v, Batch* b) { v.erase(std::remove(v.begin(), v.end(), b), v.end()); }

// The school owns batches (unique_ptr): cancelling destroys the batch and its sessions.
struct School {
    std::vector<std::unique_ptr<Batch>> batches;

    Batch& open(const std::string& name, Teacher& t, std::vector<std::string> topics) {
        auto b = std::make_unique<Batch>(Batch{name, &t, {}, {}});
        for (auto& x : topics) b->sessions.push_back({x});
        t.batches.push_back(b.get());
        batches.push_back(std::move(b));
        return *batches.back();
    }

    void cancel(Batch& b) {
        erase(b.teacher->batches, &b);
        for (Student* st : b.students) erase(st->batches, &b);
        std::erase_if(batches, [&](const std::unique_ptr<Batch>& p) { return p.get() == &b; });
    }
};

template <class List>
std::string names(const List& list) {
    std::string out;
    for (const auto& b : list) out += (out.empty() ? "" : ", ") + b->name;
    return out.empty() ? "(none)" : out;
}

// Uses a batch only for a moment (dependency): keeps no reference.
void printSummary(const Batch& b) {
    std::string st;
    for (const Student* s : b.students) st += (st.empty() ? "" : ", ") + s->name;
    std::printf("%s: teacher %s, %zu sessions, students %s\n", b.name.c_str(), b.teacher->name.c_str(),
                b.sessions.size(), st.c_str());
}

int main() {
    School school;
    Teacher karim{"Karim", {}};
    Student rahim{"Rahim", {}}, nadia{"Nadia", {}};

    Batch& physics = school.open("HSC-Physics", karim, {"Vectors", "Motion", "Waves"});
    Batch& math = school.open("HSC-Math", karim, {"Matrices", "Calculus"});
    physics.enroll(rahim);
    physics.enroll(nadia);
    math.enroll(rahim);

    printSummary(physics);
    printSummary(math);
    std::printf("Rahim's batches: %s\n", names(rahim.batches).c_str());

    std::printf("cancel %s: its %zu sessions go with it\n", physics.name.c_str(), physics.sessions.size());
    school.cancel(physics);  // physics is destroyed here; don't touch it again
    std::printf("Karim still exists, teaches: %s\n", names(karim.batches).c_str());
    std::printf("Rahim still exists, batches: %s\n", names(rahim.batches).c_str());
    std::printf("Nadia still exists, batches: %s\n", names(nadia.batches).c_str());
    std::printf("open batches: %s\n", names(school.batches).c_str());
}