Unified Modeling Language (UML)

In words (Lab-05, BR-02): "A student cannot register twice for the same event."

In the class diagram: Student "1" -- "0..*" Registration allows many registrations per student, so multiplicity cannot express the rule. UML needs a constraint in braces, attached as a note: {a student has at most one active Registration per Event}.

In C++: only code actually enforces it.

bool alreadyRegistered(const std::vector<Registration>& regs,
                       const std::string& studentId, int eventId)
{
    return std::ranges::any_of(regs, [&](const Registration& r) {
        return r.studentId() == studentId
            && r.eventId() == eventId
            && r.status() != RegistrationStatus::Cancelled;
    });
}

Modes after Fowler, UML Distilled (3rd ed., 2003).

// include/clubhub/club.hpp
#pragma once
#include <string>
#include <vector>
#include "clubhub/event.hpp"

namespace clubhub {

// «enumeration» ClubStatus
enum class ClubStatus { Pending, Approved, Rejected };

class Club {
public:
    explicit Club(std::string name) : name_{std::move(name)} {}

    void approve() { status_ = ClubStatus::Approved; }
    // only an approved club may publish (business rule)
    void publish(Event e);

    const std::string& name() const { return name_; }
    ClubStatus status() const { return status_; }
    const std::vector<Event>& events() const { return events_; }

private:
    std::string name_;
    ClubStatus status_ = ClubStatus::Pending;
    // composition "1" *-- "0..*": the club owns its events
    std::vector<Event> events_;
};

} // namespace clubhub

classDiagram
  class EventRepository {
    <<interface>>
    +findById(id: int) optional~Event~
    +save(e: Event) void
  }
  class CsvEventRepository {
    -file: path
  }
  class InMemoryEventRepository {
    -events: vector~Event~
  }
  EventRepository <|.. CsvEventRepository
  EventRepository <|.. InMemoryEventRepository

// include/clubhub/event_repository.hpp
// «interface» -> abstract class with pure virtual functions
class EventRepository {
public:
    virtual ~EventRepository() = default;
    virtual std::optional<Event> findById(int id) const = 0;
    virtual void save(const Event& e) = 0;
};

// realization (dashed line, hollow triangle) -> public inheritance
class CsvEventRepository : public EventRepository {
public:
    explicit CsvEventRepository(std::filesystem::path file)
        : file_{std::move(file)} {}
    std::optional<Event> findById(int id) const override;
    void save(const Event& e) override;
private:
    std::filesystem::path file_;
};

• Generalization (solid line, hollow triangle): "is a kind of". Realization (dashed): "implements this interface". In C++ both become public inheritance.
• InMemoryEventRepository lets unit tests run without files (Chapter 09). Prefer small interfaces over deep inheritance trees.

// (1) one class, one header
#pragma once
#include <chrono>
#include <string>

namespace clubhub {

// (2) «enumeration» -> enum class
enum class RegistrationStatus { Registered, Cancelled, CheckedIn, Waitlisted };

class Registration {
public:
    // (3) every "1" end must be supplied when the object is created
    Registration(int id, int eventId, std::string studentId,
                 std::chrono::sys_seconds registeredAt);
    // (4) + operations -> public member functions
    void cancel(std::chrono::sys_seconds now,
                std::chrono::sys_seconds eventStart);
    void checkIn();
    int eventId() const { return eventId_; }
    const std::string& studentId() const { return studentId_; }
    RegistrationStatus status() const { return status_; }
private:
    // (5) - attributes -> private data members
    int id_;
    // (6) association to Event ("1" end) -> the event's id
    int eventId_;
    // (7) association to Student ("1" end) -> the student's id
    std::string studentId_;
    RegistrationStatus status_ = RegistrationStatus::Registered;
    std::chrono::sys_seconds registeredAt_;
};

} // namespace clubhub

// src/registration_service.cpp
Registration RegistrationService::registerStudent(
    const std::string& studentId, int eventId,
    std::chrono::sys_seconds now)
{
    // message findById(12) to the EventRepository lifeline
    const std::optional<Event> event = events_.findById(eventId);
    if (!event) {
        throw RegistrationError{"no such event"};
    }
    // message countActive(12) to the RegistrationRepository lifeline
    const int active = registrations_.countActive(eventId);

    // alt [event is full]
    if (active >= event->capacity()) {
        throw RegistrationError{"event is full"};
    }
    // else [seats left]: save(registration), then return it
    Registration r{registrations_.nextId(), eventId, studentId, now};
    registrations_.save(r);
    return r;
}

// include/clubhub/registration_service.hpp
class RegistrationService {
public:
    RegistrationService(EventRepository& events,
                        RegistrationRepository& regs)
        : events_{events}, registrations_{regs} {}
    Registration registerStudent(
        const std::string& studentId, int eventId,
        std::chrono::sys_seconds now);
private:
    EventRepository& events_;
    RegistrationRepository& registrations_;
};

• Activity diagrams model workflows: a business process, a use case's steps, or an algorithm.
• Mermaid has no true swimlanes; labelled subgraphs are a common approximation. draw.io and PlantUML draw real partitions.

UML 2.5.1, clause 15 (Activities).

// src/registration_rules.cpp
enum class Trigger { SeatFreed, Cancel, CheckIn };

// Returns the next state; throws for an arrow that is not in the diagram.
RegistrationStatus next(RegistrationStatus from, Trigger t)
{
    // C++20: write Registered instead of RegistrationStatus::Registered
    using enum RegistrationStatus;
    switch (from) {
    case Waitlisted:
        if (t == Trigger::SeatFreed) return Registered;
        if (t == Trigger::Cancel)    return Cancelled;
        break;
    case Registered:
        if (t == Trigger::Cancel)    return Cancelled;
        if (t == Trigger::CheckIn)   return CheckedIn;
        break;
    case Cancelled:
    case CheckedIn:
        break;   // final states: no arrow leaves them
    }
    throw std::logic_error{"illegal transition from "
                           + std::string{toString(from)}};
}

// the guard [start - now >= 24 h] lives in the operation
void Registration::cancel(std::chrono::sys_seconds now,
                          std::chrono::sys_seconds eventStart)
{
    using namespace std::chrono_literals;
    if (eventStart - now < 24h) {
        throw RegistrationError{"cancellation closed"};
    }
    status_ = next(status_, Trigger::Cancel);
}