Object Lifetime, Resource Management (RAII) & Design

+-------------------------------------------------------------------------+
|                    THE SEVEN FATAL RESOURCE VULNERABILITIES             |
+---------------------+---------------------------------------------------+
| Vulnerability       | Systems Failure & Security Manifestation          |
+---------------------+---------------------------------------------------+
| 1. Memory Leaks     | Gradual heap exhaustion; OS kills process via     |
|                     | Out-Of-Memory (OOM) killer after days of uptime   |
+---------------------+---------------------------------------------------+
| 2. Double Free      | Calling free() twice on same pointer; corrupts    |
|                     | heap bin metadata, enabling arbitrary code exec   |
+---------------------+---------------------------------------------------+
| 3. Use-After-Free   | Accessing memory after deallocation; top source   |
|    (UAF Exploits)   | of remote zero-day browser and kernel exploits    |
+---------------------+---------------------------------------------------+
| 4. Dangling Pointer | Pointers referencing expired stack frames or      |
|                     | reallocated heap addresses; undefined behavior    |
+---------------------+---------------------------------------------------+
| 5. Descriptor Leaks | Failing to close sockets/files; system hits the   |
|                     | 1024 open file limit (EMFILE), dropping traffic   |
+---------------------+---------------------------------------------------+
| 6. Deadlocks        | Returning early without releasing a mutex lock;   |
|                     | all collaborating worker threads hang permanently |
+---------------------+---------------------------------------------------+
| 7. Uninitialized Mem| Reading raw heap memory before writing; leaks     |
|                     | cryptographic keys and passwords to network       |
+---------------------+---------------------------------------------------+

+-------------------------------------------------------------------------+
|                  THE RAII SCOPE BOUNDARY LIFECYCLE                      |
+-------------------------------------------------------------------------+
|                                                                         |
|  {                                                                      |
|      // 1. CONSTRUCTOR EXECUTION                                        |
|      // Acquires resource (opens file, allocates memory, locks mutex)   |
|      FileHandle file("data.csv");                                       |
|      std::lock_guard<std::mutex> lock(my_mutex);                        |
|                                                                         |
|      // 2. CRITICAL SECTION                                             |
|      // Work is performed... Exceptions may be thrown!                  |
|      do_risky_io_operation();                                           |
|                                                                         |
|  }   // 3. LEXICAL SCOPE EXIT (AUTOMATIC DESTRUCTOR INVOCATION)         |
|      // Guaranteed by compiler! Destructors run in reverse order:      |
|      //   - lock.~lock_guard() -> Releases mutex lock                   |
|      //   - file.~FileHandle() -> Closes physical file descriptor       |
|                                                                         |
+-------------------------------------------------------------------------+

+-------------------------------------------------------------------------+
|                  THE LIFECYCLE MANAGEMENT CANONICAL RULES               |
+---------------------+---------------------------+-----------------------+
| RULE                | CONTEXT & MECHANICS       | CANONICAL METHODS     |
+---------------------+---------------------------+-----------------------+
| Rule of Three       | C++98: Manual heap memory | 1. Destructor         |
|                     | management requires deep  | 2. Copy Constructor   |
|                     | copy mechanics            | 3. Copy Assignment    |
+---------------------+---------------------------+-----------------------+
| Rule of Five        | C++11: Move semantics     | 1. Destructor         |
|                     | introduces rvalue pointer | 2. Copy Constructor   |
|                     | theft without memory copy | 3. Copy Assignment    |
|                     |                           | 4. Move Constructor   |
|                     |                           | 5. Move Assignment    |
+---------------------+---------------------------+-----------------------+
| Rule of Zero        | Modern C++: Let smart     | NO custom destructors |
| (Modern Standard)   | pointers handle ownership | or copy/move methods! |
|                     | automatically             | Default compiler gen  |
+---------------------+---------------------------+-----------------------+

// Move Constructor: Stealing pointers in O(1) time
Buffer::Buffer(Buffer&& other) noexcept {
    this->data = other.data;       // Steal raw heap pointer
    this->size = other.size;
    other.data = nullptr;          // Nullify source so its destructor does nothing!
    other.size = 0;
}

+-------------------------------------------------------------------------+
|                  THE SMART POINTER ARCHITECTURE TRINITY                 |
+------------------+-------------------+-------------------+--------------+
| Pointer Type     | Ownership Model   | Runtime Overhead  | Move / Copy  |
+------------------+-------------------+-------------------+--------------+
| std::unique_ptr  | Exclusive         | 0 bytes overhead; | Move-only    |
|                  | (Single owner)    | identical to raw  | (Non-copy)   |
+------------------+-------------------+-------------------+--------------+
| std::shared_ptr  | Shared ownership  | 16 bytes control  | Copyable     |
|                  | (Reference count) | block; atomic inc | & Movable    |
+------------------+-------------------+-------------------+--------------+
| std::weak_ptr    | Non-owning        | Observes shared;  | Copyable     |
|                  | observer          | no ref count hold | & Movable    |
+------------------+-------------------+-------------------+--------------+

+-------------------------------------------------------------------------+
|                  RAII VS. TRACING GARBAGE COLLECTION                    |
+---------------------+---------------------------+-----------------------+
| DIMENSION           | RAII (C++, Rust)          | GARBAGE COLLECTION    |
+---------------------+---------------------------+-----------------------+
| Memory Reclamation  | Deterministic (Instant    | Non-deterministic     |
|                     | upon scope exit)          | (Deferred until GC)   |
+---------------------+---------------------------+-----------------------+
| Non-Memory Resource | Handled identically       | Handled poorly;       |
| Management          | (Files, locks, sockets)   | requires explicit     |
|                     |                           | disposal constructs   |
+---------------------+---------------------------+-----------------------+
| CPU Overhead        | Zero runtime background   | Jitter & pauses       |
|                     | threads; predictable      | (Stop-the-world,      |
|                     | sub-nanosecond execution  | cache invalidation)   |
+---------------------+---------------------------+-----------------------+
| Memory Footprint    | Minimal; memory freed     | High; requires 2x-3x  |
|                     | immediately               | headroom for GC runs  |
+---------------------+---------------------------+-----------------------+

+-------------------------------------------------------------------------+
|                  THE THREE INVIOLABLE LAWS OF RUST OWNERSHIP            |
+-------------------------------------------------------------------------+
|                                                                         |
|  1. Each value in Rust has a variable that is its OWNER.                |
|                                                                         |
|  2. There can only be ONE OWNER at any given instant.                   |
|     (Assigning or passing a value MOVES ownership; source is dead!)     |
|                                                                         |
|  3. When the owner goes OUT OF SCOPE, the value is DROPPED immediately. |
|     (The Drop trait executes automatic, deterministic RAII cleanup).    |
|                                                                         |
+-------------------------------------------------------------------------+

+-------------------------------------------------------------------------+
|                  OBJECT POOL ARCHITECTURAL TOPOLOGY                     |
+-------------------------------------------------------------------------+
|                                                                         |
|  CLIENT WORKER THREAD                   OBJECT POOL MANAGER             |
|                                         +-----------------------------+ |
|  1. Requests resource                   | Available Pool: [O1, O2, O3]| |
|     pool.acquire() -------------------> | In-Use Registry: []         | |
|                                         +--------------+--------------+ |
|                                                        |                |
|  2. Receives RAII checkout handle                      v                |
|     <---------------------------------- Grants O1 (Moves to In-Use)     |
|                                                                         |
|  3. Performs transactions using O1                                      |
|                                                                         |
|  4. Scope exits! Handle destructor                                      |
|     automatically returns O1 to pool ----------------->                 |
|                                         +-----------------------------+ |
|                                         | Available Pool: [O2, O3, O1]| |
|                                         | (O1 scrubbed & ready)       | |
|                                         +-----------------------------+ |
|                                                                         |
+-------------------------------------------------------------------------+

# ============================================================================
# RAII LIFECYCLE MANAGEMENT & OBJECT POOL ARCHITECTURE
# ============================================================================

from typing import List, Set, Any, Optional
import threading
import time
import uuid

# ----------------------------------------------------------------------------
# 1. LOW-LEVEL RESOURCE EMULATION: Virtual File Descriptor
# ----------------------------------------------------------------------------

class VirtualFileDescriptor:
    '''Simulates an operating system hardware file handle with leak tracking.'''
    OPEN_HANDLES: Set[int] = set()
    _HANDLE_LOCK = threading.Lock()
    _COUNTER = 100

    def __init__(self, filename: str):
        self.filename = filename
        with self._HANDLE_LOCK:
            VirtualFileDescriptor._COUNTER += 1
            self.fd = VirtualFileDescriptor._COUNTER
            VirtualFileDescriptor.OPEN_HANDLES.add(self.fd)
        self.is_open = True
        print(f"  [OS KERNEL] Allocated descriptor FD={self.fd} for '{filename}'")

    def write(self, payload: str) -> None:
        if not self.is_open:
            raise IOError(f"Descriptor FD={self.fd} is closed! Cannot write.")
        print(f"  [DISK IO] Wrote {len(payload)} bytes to FD={self.fd}: '{payload}'")

    def close(self) -> None:
        if self.is_open:
            with self._HANDLE_LOCK:
                VirtualFileDescriptor.OPEN_HANDLES.remove(self.fd)
            self.is_open = False
            print(f"  [OS KERNEL] Released descriptor FD={self.fd}")


# ----------------------------------------------------------------------------
# 2. PYTHON RAII RESOURCE GUARD (Context Manager)
# ----------------------------------------------------------------------------

class FileHandleGuard:
    '''
    RAII Scope Guard for VirtualFileDescriptor.
    Guarantees deterministic closure upon scope exit or exception.
    '''
    def __init__(self, filename: str):
        self.filename = filename
        self.handle: Optional[VirtualFileDescriptor] = None

    def __enter__(self) -> VirtualFileDescriptor:
        # Acquisition is Initialization
        self.handle = VirtualFileDescriptor(self.filename)
        return self.handle

    def __exit__(self, exc_type, exc_val, exc_tb) -> bool:
        # Deterministic Destructor Cleanup
        if self.handle:
            self.handle.close()
        # Return False so any unhandled exceptions continue propagating
        return False


# ----------------------------------------------------------------------------
# 3. BOUNDED THREAD-SAFE OBJECT POOL
# ----------------------------------------------------------------------------

class HeavyNetworkBuffer:
    '''Simulates a heavyweight 16MB network DMA packet buffer.'''
    def __init__(self, buffer_id: str):
        self.buffer_id = buffer_id
        self.payload: bytearray = bytearray(1024)
        self.in_use: bool = False
        self.bytes_written: int = 0

    def write_packet(self, data: bytes) -> None:
        self.payload[:len(data)] = data
        self.bytes_written = len(data)

    def reset(self) -> None:
        '''Scrubbing protocol to prevent cross-transaction pollution.'''
        self.payload = bytearray(1024)
        self.bytes_written = 0
        self.in_use = False

    def __repr__(self) -> str:
        return f"Buffer(id={self.buffer_id}, used={self.bytes_written}B)"


class BoundedBufferPool:
    '''Manages pre-allocated buffers with RAII checkout mechanics.'''
    def __init__(self, capacity: int = 3):
        self.capacity = capacity
        self._available: List[HeavyNetworkBuffer] = [
            HeavyNetworkBuffer(f"BUF-{i}") for i in range(capacity)
        ]
        self._lock = threading.Lock()

    def acquire(self) -> HeavyNetworkBuffer:
        with self._lock:
            if not self._available:
                raise RuntimeError("Pool Exhaustion: No available buffers in pool!")
            buf = self._available.pop()
            buf.in_use = True
            return buf

    def release(self, buf: HeavyNetworkBuffer) -> None:
        with self._lock:
            buf.reset() # Scrub state
            self._available.append(buf)

    @property
    def available_count(self) -> int:
        with self._lock:
            return len(self._available)


class PooledBufferHandle:
    '''RAII handle that automatically returns the buffer to the pool on exit.'''
    def __init__(self, pool: BoundedBufferPool):
        self.pool = pool
        self.buffer: Optional[HeavyNetworkBuffer] = None

    def __enter__(self) -> HeavyNetworkBuffer:
        self.buffer = self.pool.acquire()
        return self.buffer

    def __exit__(self, exc_type, exc_val, exc_tb) -> bool:
        if self.buffer:
            self.pool.release(self.buffer)
        return False


# ----------------------------------------------------------------------------
# 4. EXECUTION & VERIFICATION HARNESS
# ----------------------------------------------------------------------------

if __name__ == "__main__":
    print("=" * 70)
    print("1. VERIFYING DETERMINISTIC RAII RESOURCE CLEANUP:")
    print("=" * 70)
    
    # Normal execution path
    with FileHandleGuard("system_audit.log") as handle:
        handle.write("Transaction #1001 Committed.")
    assert len(VirtualFileDescriptor.OPEN_HANDLES) == 0, "Descriptor leaked on normal exit!"
    print("  [SUCCESS] Descriptor closed automatically on scope exit.")

    print("\n" + "=" * 70)
    print("2. VERIFYING RAII CLEANUP DURING UNHANDLED EXCEPTIONS:")
    print("=" * 70)
    try:
        with FileHandleGuard("panic_dump.core") as handle:
            handle.write("Kernel panic trace initiating...")
            raise RuntimeError("Fatal power loss simulation!")
    except RuntimeError as err:
        print(f"  Caught expected exception: '{err}'")

    assert len(VirtualFileDescriptor.OPEN_HANDLES) == 0, "Descriptor leaked during exception unwinding!"
    print("  [SUCCESS] Exception stack unwinding closed descriptor with 100% reliability.")

    print("\n" + "=" * 70)
    print("3. VERIFYING RAII BOUNDED OBJECT POOL & STATE SCRUBBING:")
    print("=" * 70)
    pool = BoundedBufferPool(capacity=2)
    print(f"Initial available buffers: {pool.available_count}")

    # Check out buffer using RAII handle
    with PooledBufferHandle(pool) as b1:
        b1.write_packet(b"GET /api/v1/telemetry HTTP/1.1")
        print(f"  Checked out {b1}, remaining pool: {pool.available_count}")
        assert pool.available_count == 1, "Pool capacity counter corrupted!"

    # Exited scope: Buffer must be recycled and scrubbed
    print(f"After scope exit, pool available: {pool.available_count}")
    assert pool.available_count == 2, "Buffer was not recycled to pool!"
    
    # Re-acquire to prove scrubbing occurred
    with PooledBufferHandle(pool) as b2:
        print(f"Re-acquired buffer: {b2}")
        assert b2.bytes_written == 0, "Security failure: Buffer payload was not scrubbed!"
        print("  [SUCCESS] Recycled buffer was completely scrubbed and reset.")

int* raw = new int(42);
std::unique_ptr<int> p1(raw);
std::unique_ptr<int> p2(raw); // CATASTROPHIC BUG: Double Free!

class LedgerAccount {
public:
    double balance;
    std::vector<std::string> transaction_log;
};

void transfer_funds(LedgerAccount& from, LedgerAccount& to, double amount, std::string tx_id) {
    if (from.balance < amount) throw std::invalid_argument("Insufficient funds");
    
    // Step 1: Mutate source account
    from.balance -= amount;
    from.transaction_log.push_back("DEBIT: " + tx_id); // May throw std::bad_alloc!
    
    // Step 2: Mutate destination account
    to.balance += amount;
    to.transaction_log.push_back("CREDIT: " + tx_id);  // May throw std::bad_alloc!
}

#include <vector>
#include <string>
#include <stdexcept>
#include <utility>

class LedgerAccount {
public:
    double balance;
    std::vector<std::string> transaction_log;

    // Non-throwing swap
    void swap(LedgerAccount& other) noexcept {
        std::swap(balance, other.balance);
        transaction_log.swap(other.transaction_log);
    }
};

void transfer_funds_strong(LedgerAccount& from, LedgerAccount& to, double amount, const std::string& tx_id) {
    if (from.balance < amount) {
        throw std::invalid_argument("Insufficient funds");
    }

    // Step 1: Create local temporary copies (Working state)
    LedgerAccount temp_from = from;
    LedgerAccount temp_to = to;

    // Step 2: Mutate the temporary copies
    // If any vector push_back throws std::bad_alloc here, temp_from and temp_to
    // are automatically destructed by RAII, leaving 'from' and 'to' 100% untouched!
    temp_from.balance -= amount;
    temp_from.transaction_log.push_back("DEBIT: " + tx_id);

    temp_to.balance += amount;
    temp_to.transaction_log.push_back("CREDIT: " + tx_id);

    // Step 3: Commit Phase (All operations succeeded; swaps are noexcept!)
    from.swap(temp_from);
    to.swap(temp_to);
}

#include <memory>
#include <vector>
#include <string>
#include <iostream>

class DomNode {
public:
    std::string tag;
    std::shared_ptr<DomNode> parent;                // Cyclic reference trap!
    std::vector<std::shared_ptr<DomNode>> children;

    DomNode(std::string t) : tag(t) {}
    ~DomNode() {
        std::cout << "~DomNode() Destructed: " << tag << "\n";
    }

    void add_child(std::shared_ptr<DomNode> child) {
        children.push_back(child);
        child->parent = shared_from_this(); // Binds child back to parent
    }
};

void build_dom() {
    auto root = std::make_shared<DomNode>("html");
    auto body = std::make_shared<DomNode>("body");
    root->add_child(body);
} // Scope exits

+-------------------------------------------------------------------------+
|                    THE CYCLIC REFERENCE DEADLOCK                        |
+-------------------------------------------------------------------------+
|                                                                         |
|  [html Node] (use_count = 1)                                            |
|       |                                                                 |
|       |  children[0] holds shared_ptr (increments body use_count)       |
|       v                                                                 |
|  [body Node] (use_count = 1)                                            |
|       |                                                                 |
|       |  parent holds shared_ptr (increments html use_count)            |
|       +-------------------------------------------------------------+   |
|                                                                         |
+-------------------------------------------------------------------------+

#include <memory>
#include <vector>
#include <string>
#include <iostream>

class DomNode : public std::enable_shared_from_this<DomNode> {
public:
    std::string tag;
    // WEAK POINTER: Breaks cycle! Does not increment use_count!
    std::weak_ptr<DomNode> parent;
    std::vector<std::shared_ptr<DomNode>> children;

    DomNode(std::string t) : tag(t) {}
    ~DomNode() {
        std::cout << "~DomNode() Destructed: " << tag << "\n";
    }

    void add_child(std::shared_ptr<DomNode> child) {
        children.push_back(child);
        child->parent = shared_from_this(); // Assigns weak reference
    }
};

void test_dom_cleanup() {
    auto root = std::make_shared<DomNode>("html");
    auto body = std::make_shared<DomNode>("body");
    root->add_child(body);
    // At this point:
    // root.use_count() == 1 (weak_ptr does not count!)
    // body.use_count() == 2
} // Scope exits: root.use_count() hits 0 -> html destroyed!
  // html destructor runs -> releases children[0] -> body.use_count() hits 0 -> body destroyed!

struct TokenParser<'a> {
    delimiter: &'a str,
    buffer: &'a mut String,
}

fn parse_tokens<'a>(input: &'a mut String, delim: &'a str) -> Vec<&'a str> {
    let mut tokens = Vec::new();
    let mut parser = TokenParser {
        delimiter: delim,
        buffer: input,
    };
    
    // Split on delimiter
    for part in parser.buffer.split(parser.delimiter) {
        tokens.push(part);
    }
    
    // Malicious or accidental mutation while tokens borrow buffer!
    parser.buffer.push_str("_TERMINATOR");
    
    tokens
}

pub fn parse_tokens_clean<'a>(input: &'a str, delim: &str) -> Vec<&'a str> {
    // Borrow input immutably throughout the entire operation
    input.split(delim).collect()
}

pub fn append_terminator(input: &mut String) {
    input.push_str("_TERMINATOR");
}

#include <vector>
#include <memory>
#include <atomic>
#include <stdexcept>

class OrderContext {
public:
    int order_id;
    double price;
    void reset() { order_id = 0; price = 0.0; }
};

class LockFreeOrderPool {
private:
    std::vector<OrderContext> storage;
    std::vector<OrderContext*> available_stack;
    std::atomic<int> head;

public:
    LockFreeOrderPool(size_t capacity) : storage(capacity), available_stack(capacity), head(capacity) {
        for (size_t i = 0; i < capacity; ++i) {
            available_stack[i] = &storage[i];
        }
    }

    OrderContext* acquire() {
        int current_head = head.load(std::memory_order_relaxed);
        while (current_head > 0) {
            if (head.compare_exchange_weak(current_head, current_head - 1,
                                          std::memory_order_acquire,
                                          std::memory_order_relaxed)) {
                return available_stack[current_head - 1];
            }
        }
        throw std::runtime_error("Pool Exhaustion!");
    }

    void release(OrderContext* ctx) {
        ctx->reset(); // Scrubbing protocol
        int current_head = head.load(std::memory_order_relaxed);
        while (true) {
            available_stack[current_head] = ctx;
            if (head.compare_exchange_weak(current_head, current_head + 1,
                                          std::memory_order_release,
                                          std::memory_order_relaxed)) {
                return;
            }
        }
    }
};

// RAII Scope Guard
class OrderContextGuard {
private:
    LockFreeOrderPool& pool;
    OrderContext* ctx;
public:
    OrderContextGuard(LockFreeOrderPool& p) : pool(p), ctx(p.acquire()) {}
    ~OrderContextGuard() {
        if (ctx) pool.release(ctx);
    }
    OrderContext* get() const { return ctx; }
    OrderContext* operator->() const { return ctx; }

    // Prevent copying to maintain unique ownership
    OrderContextGuard(const OrderContextGuard&) = delete;
    OrderContextGuard& operator=(const OrderContextGuard&) = delete;
};