impl.h

Go to the documentation of this file.

#pragma once

 
// IWYU pragma: begin_keep
#include "platforms/shared/spi_manager.h"  // ok platform headers
#include "platforms/shared/spi_types.h"  // ok platform headers
#include "platforms/shared/spi_hw_base.h"  // ok platform headers
#include "fl/log/log.h"
#include "fl/stl/noexcept.h"
// IWYU pragma: end_keep
 
namespace fl {
namespace spi {

struct Device::Impl {
    Config config;                      
    SPIBusHandle bus_handle;            
    bool initialized;                   

    struct AsyncState {
        bool active;                    
        const u8* tx_buffer;       
        u8* rx_buffer;             
        size_t size;                    
        u32 start_time;            
    } async_state;

    fl::shared_ptr<SpiHwBase> hw_backend;

    bool owns_backend;

    explicit Impl(const Config& cfg)
        FL_NO_EXCEPT : config(cfg)
        , bus_handle()
        , initialized(false)
        , async_state{false, nullptr, nullptr, 0, 0}
        , hw_backend(nullptr)
        , owns_backend(false) {}

    ~Impl() FL_NO_EXCEPT {
        FL_LOG_SPI("Device::Impl: Destructor called");
        // Members will be destroyed in reverse order of declaration:
        // 1. owns_backend (bool) - trivial
        // 2. hw_backend (void*) - trivial (pointer not owned here)
        // 3. async_state (struct) - trivial
        // 4. initialized (bool) - trivial
        // 5. bus_handle (struct) - trivial
        // 6. config (Config) - contains fl::vector which might cause issues
        FL_LOG_SPI("Device::Impl: Destructor complete");
    }
};

struct Transaction::Impl {
    Device* device;                     
    bool completed;                     
    bool cancelled;                     
    fl::optional<fl::task::Error> result;     
    u32 timeout_ms;                
 
    // Platform-specific completion tracking
#ifdef FL_IS_ESP32
    void* notify_task;                  
#endif

    explicit Impl(Device* dev)
        FL_NO_EXCEPT : device(dev)
        , completed(false)
        , cancelled(false)
        , result(fl::nullopt)  // nullopt = success
        , timeout_ms((fl::numeric_limits<u32>::max)())
#ifdef FL_IS_ESP32
        , notify_task(nullptr)
#endif
    {}
};
 
} // namespace spi
} // namespace fl