C++14/17 Features for Adaptive AUTOSAR

#include 
#include 
#include 

// C++14: generic lambdas, relaxed constexpr, make_unique

// auto return type deduction (C++14)
auto compute_crc(const uint8_t *data, std::size_t len) noexcept -> uint32_t {
    uint32_t crc = 0xFFFFFFFFu;
    for (std::size_t i = 0u; i < len; ++i) {
        crc ^= data[i];
        for (uint8_t j = 0u; j < 8u; ++j) {
            crc = (crc & 1u) ? ((crc >> 1u) ^ 0xEDB88320u) : (crc >> 1u);
        }
    }
    return ~crc;
}

// std::optional (C++17, but widely used in C++14 via ARA): no nullptr + value
// Replaces "bool + out-param" pattern
std::optional read_calibration_value(uint8_t channel) noexcept {
    if (channel >= ADC_MAX_CHANNELS) { return std::nullopt; }
    uint16_t val = ADC_Read(channel);
    if (val == 0xFFFFu) { return std::nullopt; }  // invalid sensor reading
    return val;  // valid value wrapped in optional
}

// Usage: explicit check required before accessing value
auto val = read_calibration_value(3u);
if (val.has_value()) {
    float voltage = static_cast(*val) * 3.3f / 4095.0f;
}

#include "ara/com/types.h"
#include "ara/core/result.h"
#include "ara/core/string_view.h"
#include 
#include 

// ara::core::Result: explicit error handling without exceptions
// Replaces errno-style or bool+output-param patterns
ara::core::Result
ReadServiceData(ara::core::StringView service_name) noexcept
{
    auto *svc = ServiceRegistry::find(service_name);
    if (svc == nullptr) {
        return ara::core::Result::FromError(
            ara::core::ErrorCode{kServiceNotFound});
    }
    return svc->getData();  // returns Result with value
}

// C++17 if constexpr: compile-time branch selection (replaces template specialisation)
template
void serialize(uint8_t *buf, T val) noexcept {
    if constexpr (std::is_same_v) {
        buf[0] = val;
    } else if constexpr (std::is_same_v) {
        buf[0] = static_cast(val >> 8u);
        buf[1] = static_cast(val & 0xFFu);
    } else if constexpr (std::is_same_v) {
        for (uint8_t i = 0u; i < 4u; ++i) {
            buf[3u - i] = static_cast((val >> (i * 8u)) & 0xFFu);
        }
    }
}

// std::variant: type-safe union (replaces void* + type tag pattern)
using SensorValue = std::variant;
SensorValue read_sensor(uint8_t type) noexcept {
    switch (type) {
        case 0u: return static_cast(ADC_Read(0u));
        case 1u: return static_cast(ADC_Read(1u)) * (3.3f / 4095.0f);
        default: return true;  // digital sensor
    }
}