Ownership in Designs

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

// Non-owning observer interface
class ILogger {
public:
    virtual ~ILogger() = default;
    virtual void log(std::string_view msg) const = 0;
};

class ConsoleLogger final : public ILogger {
public:
    void log(std::string_view msg) const override {
        std::println("[LOG] {}", msg);
    }
};

// Pure virtual interface for payment strategy
class PaymentProcessor {
public:
    virtual ~PaymentProcessor() = default;
    virtual bool process(int amountRupees) = 0;
};

class UpiProcessor final : public PaymentProcessor {
    std::string vpa_;
public:
    explicit UpiProcessor(std::string vpa) : vpa_(std::move(vpa)) {}
    bool process(int amountRupees) override {
        std::println("[UPI] Debited Rs.{} via {}", amountRupees, vpa_);
        return true;
    }
    [[nodiscard]] const std::string& vpa() const noexcept { return vpa_; }
};

// Shared domain entity: UserSession
class UserSession {
    std::string userId_;
public:
    explicit UserSession(std::string userId) : userId_(std::move(userId)) {
        std::println("UserSession created for {}", userId_);
    }
    ~UserSession() {
        std::println("UserSession destroyed for {}", userId_);
    }
    [[nodiscard]] const std::string& userId() const noexcept { return userId_; }
};

// Audit observer holding weak_ptr to prevent cycle and avoid extending lifetime
class AuditObserver {
    std::weak_ptr<UserSession> sessionWeak_;
public:
    explicit AuditObserver(std::weak_ptr<UserSession> session)
        : sessionWeak_(std::move(session)) {}

    void auditEvent(std::string_view event) const {
        if (auto session = sessionWeak_.lock()) {
            std::println("[AUDIT] User '{}' performed: {}", session->userId(), event);
        } else {
            std::println("[AUDIT] (Session expired) Unauthenticated event: {}", event);
        }
    }

    [[nodiscard]] bool isSessionAlive() const noexcept {
        return !sessionWeak_.expired();
    }
};

// Order domain entity
struct Order {
    std::string orderId;
    int amountRupees;
};

// OrderService:
// 1. Exclusively owns PaymentProcessor via std::unique_ptr
// 2. Shares UserSession via std::shared_ptr
// 3. Borrows ILogger via non-owning reference ILogger&
// 4. Copies are explicitly deleted (= delete)
class OrderService {
    std::unique_ptr<PaymentProcessor> processor_;
    std::shared_ptr<UserSession> session_;

public:
    OrderService(std::unique_ptr<PaymentProcessor> processor,
                 std::shared_ptr<UserSession> session)
        : processor_(std::move(processor)), session_(std::move(session)) {}

    // Rule of 5: Prevent accidental slicing and duplicated ownership
    OrderService(const OrderService&) = delete;
    OrderService& operator=(const OrderService&) = delete;

    OrderService(OrderService&&) noexcept = default;
    OrderService& operator=(OrderService&&) noexcept = default;

    bool checkout(const Order& order, const ILogger& logger) {
        logger.log(std::format("Checking out order {} for Rs.{}", order.orderId, order.amountRupees));
        if (!processor_) {
            logger.log("Error: No payment processor attached");
            return false;
        }
        return processor_->process(order.amountRupees);
    }

    [[nodiscard]] const std::shared_ptr<UserSession>& session() const noexcept {
        return session_;
    }

    [[nodiscard]] bool hasProcessor() const noexcept {
        return processor_ != nullptr;
    }
};

int main() {
    ConsoleLogger logger;

    // 1. Exclusive ownership: std::make_unique transferred via std::move
    auto upi = std::make_unique<UpiProcessor>("naman@oksbi");

    // 2. Shared ownership: session shared between OrderService and AuditObserver
    auto session = std::make_shared<UserSession>("USR-404");
    AuditObserver auditor(session);

    std::println("Initial session use_count: {}", session.use_count());

    // 3. Move unique_ptr into OrderService (ownership transfer)
    OrderService service(std::move(upi), session);
    std::println("Session use_count after service creation: {}", session.use_count());

    // 4. Execute checkout borrowing logger as non-owning observer
    Order order{"ORD-901", 1250};
    service.checkout(order, logger);
    auditor.auditEvent("PaymentCompleted");

    // 5. Release main's shared ownership
    session.reset();
    std::println("Session use_count after main reset: {}", service.session().use_count());

    // 6. Demonstrate weak_ptr expiration when all shared_ptrs are destroyed
    {
        OrderService tempService = std::move(service);
        // tempService goes out of scope here
    }

    std::println("Checking auditor after session destruction:");
    auditor.auditEvent("PostLogoutAction");

    return 0;
}