Revisión de Código: SensorManager

// sensor_manager.h — VIOLACIONES MARCADAS
#pragma once
#include <string>
#include <vector>
#include <mutex>
#include <queue>
using namespace std;  // ❌ SF.7

#define MAX_SENSORS 256  // ❌ Enum.1
#define PI 3.14159       // ❌ Enum.1

class SensorManager {
public:
    SensorManager() {}

    // ❌ I.11: raw pointer ownership
    void add_sensor(Sensor* s);

    // ❌ F.20: output params
    void get_reading(int id,
        double& out_val,
        bool& out_ok);

    // ❌ C.35: no virtual destructor
    ~SensorManager();

    // ❌ C.46: no explicit
    SensorManager(int capacity);

private:
    // ❌ R.3/R.20: owning raw ptrs
    vector<Sensor*> sensors_;
    // ❌ SL.con.1: C array
    double readings[256];
    mutex mtx;
    queue<double> data_q;
    // ❌ ES.23
    int count = 0;
};

// ❌ Enum.3 + Enum.5
enum SensorType {
    TEMPERATURE, HUMIDITY, PRESSURE
};

// sensor_manager.h — VERSIÓN CORREGIDA
#pragma once
#include <array>
#include <memory>
#include <mutex>
#include <optional>
#include <queue>
#include <string>
#include <vector>
// ✅ Sin "using namespace" (SF.7)

namespace novatech {

// ✅ Enum.1: constexpr en lugar de #define
constexpr std::size_t k_max_sensors{256};
constexpr double k_pi{3.14159265358979};

// ✅ Enum.3 + Enum.5: enum class, no ALL_CAPS
enum class SensorType {
    temperature, humidity, pressure
};

class SensorManager {
public:
    SensorManager() = default;

    // ✅ C.46: explicit
    explicit SensorManager(std::size_t capacity);

    // ✅ C.35: virtual destructor
    virtual ~SensorManager() = default;

    // ✅ I.11: transfiere por unique_ptr
    void add_sensor(std::unique_ptr<Sensor> s);

    // ✅ F.20: return value con optional
    std::optional<double> get_reading(
        std::size_t id) const;

    // ✅ Con.2: observadoras const
    std::size_t sensor_count() const noexcept;

private:
    // ✅ R.20: unique_ptr gestiona ownership
    std::vector<std::unique_ptr<Sensor>> sensors_;
    // ✅ SL.con.1: std::array en lugar de C array
    std::array<double, k_max_sensors> readings_{};
    mutable std::mutex mutex_;
    std::queue<double> data_queue_;
    // ✅ ES.23: {} initializer, size_t
    std::size_t count_{};
};

} // namespace novatech

// sensor_manager.cpp

void SensorManager::get_reading(
    int id, double& out_val, bool& out_ok)
{
    // ❌ CP.20: lock manual sin RAII
    lock(mtx);
    if (id >= 0 && id < count) {
        out_val = readings[id];
        out_ok = true;
    }
    // ❌ Si se lanza excepción arriba,
    //    unlock() no se llama → deadlock
    mtx.unlock();
}

void SensorManager::add_sensor(Sensor* s)
{
    // ❌ R.20: guarda raw pointer
    sensors_.push_back(s);
    count++;
}

// Función libre con violaciones
void process_batch(
    vector<double>& results,
    SensorManager* mgr)  // ❌ I.11
{
    for (int i=0; i<mgr->count; i++) {
        double val; bool ok;
        mgr->get_reading(i, val, ok);
        if (ok) results.push_back(val);
    }
}

// sensor_manager.cpp

namespace novatech {

std::optional<double>
SensorManager::get_reading(
    std::size_t id) const
{
    // ✅ CP.20: RAII lock_guard (named)
    std::lock_guard<std::mutex> lock(mutex_);
    if (id < count_) {
        // ✅ F.20: return value (optional)
        return readings_[id];
    }
    return std::nullopt;
    // Si se lanza excepción, lock_guard
    // libera el mutex automáticamente
}

void SensorManager::add_sensor(
    std::unique_ptr<Sensor> s)
{
    std::lock_guard<std::mutex> lock(mutex_);
    // ✅ R.20: unique_ptr gestiona lifetime
    sensors_.push_back(std::move(s));
    ++count_;
}

// ✅ F.16: const ref; I.11: no raw ptr
std::vector<double> process_batch(
    const SensorManager& mgr)
{
    std::vector<double> results;
    results.reserve(mgr.sensor_count());
    for (std::size_t i{}; i < mgr.sensor_count(); ++i) {
        // ✅ F.20: optional, no output params
        if (const auto r = mgr.get_reading(i); r) {
            results.push_back(*r);
        }
    }
    return results;  // NRVO/move
}

} // namespace novatech