Reading Class Diagrams & Code Smells

#include <iostream>
#include <memory>
#include <numeric>
#include <print>
#include <string>
#include <string_view>
#include <utility>
#include <vector>

// 1. Inherits (──▷): BaseController provides shared logging and audit utilities
class BaseController {
public:
    virtual ~BaseController() = default;

    void logAction(std::string_view action) const {
        std::println("[BASE-AUDIT] Executed: {}", action);
    }
};

// 2. Implements (╌╌▷): NotificationService is a pure virtual interface contract
class NotificationService {
public:
    virtual ~NotificationService() = default;
    virtual void send(std::string_view recipient, std::string_view message) = 0;
};

class EmailNotification final : public NotificationService {
    int sentCount_{0};
public:
    void send(std::string_view recipient, std::string_view message) override {
        sentCount_++;
        std::println("[EMAIL] To {}: {}", recipient, message);
    }

    [[nodiscard]] int sentCount() const noexcept {
        return sentCount_;
    }
};

// 3. Composes (◆──▶): Order strictly owns its OrderItems (value composition)
struct OrderItem {
    std::string sku;
    int priceRupees;
    int quantity;
};

class Order {
    std::string id_;
    std::vector<OrderItem> items_; // Composition: items cannot exist outside the order

public:
    explicit Order(std::string id) : id_(std::move(id)) {}

    void addItem(std::string sku, int priceRupees, int quantity) {
        items_.push_back(OrderItem{std::move(sku), priceRupees, quantity});
    }

    [[nodiscard]] int calculateTotal() const noexcept {
        return std::accumulate(items_.begin(), items_.end(), 0,
            [](int sum, const OrderItem& it) {
                return sum + (it.priceRupees * it.quantity);
            });
    }

    [[nodiscard]] const std::string& id() const noexcept { return id_; }
    [[nodiscard]] const std::vector<OrderItem>& items() const noexcept { return items_; }
};

// 4. Aggregates (◇──▶) & Depends (╌╌▶):
// - Aggregates NotificationService via std::shared_ptr (notifier outlives controller)
// - Inherits BaseController (──▷)
// - Depends on Order as a method parameter (╌╌▶)
class OrderController final : public BaseController {
    std::shared_ptr<NotificationService> notifier_; // Aggregation: shared non-exclusive ownership

public:
    explicit OrderController(std::shared_ptr<NotificationService> notifier)
        : notifier_(std::move(notifier)) {}

    // Depends (╌╌▶): transient usage of Order without holding ownership
    bool placeOrder(const Order& order, std::string_view customerEmail) {
        logAction(std::format("placeOrder for {}", order.id()));
        int total = order.calculateTotal();

        std::println("[CONTROLLER] Order {} verified. Total: Rs.{}", order.id(), total);

        if (notifier_) {
            notifier_->send(customerEmail,
                std::format("Order {} placed successfully for Rs.{}", order.id(), total));
        }
        return true;
    }
};

int main() {
    // Aggregation participant created independently (can outlive controller)
    auto emailService = std::make_shared<EmailNotification>();

    // Controller created, aggregating emailService and inheriting BaseController
    OrderController controller(emailService);

    // Composition: Order owns its OrderItem instances
    Order order("ORD-8801");
    order.addItem("SKU-BURGER", 250, 2);
    order.addItem("SKU-FRIES", 120, 1);

    // Dependency: Order passed into placeOrder by reference
    controller.placeOrder(order, "naman@example.com");

    std::println("Notifications sent: {}", emailService->sentCount());
    return 0;
}