/home/runner/work/FastLED/FastLED/src/fl/channels/config.h

Variant type that holds either a clockless or SPI chipset configuration.

Variant type that holds either a clockless or SPI chipset configuration This allows ChannelConfig to support both chipset types with compile-time type safety and runtime polymorphism via the visitor pattern.

// Clockless chipset (WS2812)
ChipsetVariant clockless = ClocklessChipset(5, makeTimingConfig<TIMING_WS2812_800KHZ>());
 
// SPI chipset (APA102)
ChipsetVariant spi = SpiChipsetConfig(23, 18, SpiEncoder::apa102());

#pragma once
 
#include "crgb.h"  // IWYU pragma: keep
#include "fl/gfx/rgbw.h"  // IWYU pragma: keep
#include "fl/stl/span.h"
#include "fl/stl/vector.h"
#include "fl/stl/shared_ptr.h"
#include "fl/stl/variant.h"
#include "fl/math/screenmap.h"
#include "fl/chipsets/chipset_timing_config.h"
#include "fl/chipsets/clockless_encoder.h"
#include "fl/chipsets/spi.h"
#include "fl/gfx/eorder.h"
#include "fl/channels/options.h"
#include "fl/stl/optional.h"
#include "fl/stl/string.h"  // fl::string must be complete for Optional<fl::string> below  // IWYU pragma: keep
#include "color.h"  // IWYU pragma: keep
#include "dither_mode.h"  // IWYU pragma: keep
#include "fl/stl/noexcept.h"
 
namespace fl {

struct ClocklessChipset {
    int pin;                        
    ChipsetTimingConfig timing;     
    ClocklessEncoder encoder;       

    constexpr ClocklessChipset(int pin, const ChipsetTimingConfig& timing,
                               ClocklessEncoder encoder) FL_NOEXCEPT
        : pin(pin), timing(timing), encoder(encoder) {}

    constexpr ClocklessChipset(int pin, const ChipsetTimingConfig& timing) FL_NOEXCEPT
        : pin(pin), timing(timing), encoder(ClocklessEncoder::CLOCKLESS_ENCODER_WS2812) {}

    constexpr ClocklessChipset() FL_NOEXCEPT
        : pin(-1), timing(0, 0, 0, 0), encoder(ClocklessEncoder::CLOCKLESS_ENCODER_WS2812) {}

    ClocklessChipset(const ClocklessChipset&) FL_NOEXCEPT = default;

    ClocklessChipset(ClocklessChipset&&) FL_NOEXCEPT = default;

    ClocklessChipset& operator=(const ClocklessChipset&) FL_NOEXCEPT = default;

    ClocklessChipset& operator=(ClocklessChipset&&) FL_NOEXCEPT = default;

    bool operator==(const ClocklessChipset& other) const FL_NOEXCEPT {
        return pin == other.pin &&
               timing == other.timing &&
               encoder == other.encoder;
    }

    bool operator!=(const ClocklessChipset& other) const FL_NOEXCEPT {
        return !(*this == other);
    }
};

template <typename TIMING>
constexpr ClocklessChipset makeClockless(int pin) FL_NOEXCEPT {
    return ClocklessChipset(pin, makeTimingConfig<TIMING>(), encoder_for<TIMING>());
}

struct SpiChipsetConfig {
    int dataPin;                    
    int clockPin;                   
    SpiEncoder timing;              

    SpiChipsetConfig(int dataPin, int clockPin, const SpiEncoder& timing) FL_NOEXCEPT
        : dataPin(dataPin), clockPin(clockPin), timing(timing) {}

    SpiChipsetConfig() FL_NOEXCEPT : dataPin(-1), clockPin(-1), timing{fl::SpiChipset::APA102, 6000000} {}

    SpiChipsetConfig(const SpiChipsetConfig&) FL_NOEXCEPT = default;

    SpiChipsetConfig(SpiChipsetConfig&&) FL_NOEXCEPT = default;

    SpiChipsetConfig& operator=(const SpiChipsetConfig&) FL_NOEXCEPT = default;

    SpiChipsetConfig& operator=(SpiChipsetConfig&&) FL_NOEXCEPT = default;

    bool operator==(const SpiChipsetConfig& other) const FL_NOEXCEPT {
        return dataPin == other.dataPin &&
               clockPin == other.clockPin &&
               timing == other.timing;
    }

    bool operator!=(const SpiChipsetConfig& other) const FL_NOEXCEPT {
        return !(*this == other);
    }
};

using ChipsetVariant = fl::variant<ClocklessChipset, SpiChipsetConfig>;

struct ChannelConfig {
 
    // ========== New Variant-Based Constructors ==========

    ChannelConfig(const fl::string& name, const ChipsetVariant& chipset, fl::span<CRGB> leds,
                  EOrder rgbOrder = RGB, const ChannelOptions& options = ChannelOptions()) FL_NOEXCEPT;

    ChannelConfig(const ChipsetVariant& chipset, fl::span<CRGB> leds,
                  EOrder rgbOrder = RGB, const ChannelOptions& options = ChannelOptions()) FL_NOEXCEPT;

    ChannelConfig(const ClocklessChipset& clockless, fl::span<CRGB> leds,
                  EOrder rgbOrder = RGB, const ChannelOptions& options = ChannelOptions()) FL_NOEXCEPT;

    ChannelConfig(const SpiChipsetConfig& spi, fl::span<CRGB> leds,
                  EOrder rgbOrder = RGB, const ChannelOptions& options = ChannelOptions()) FL_NOEXCEPT;
 
    // ========== Backwards-Compatible Constructors (Deprecated) ==========

    template<typename TIMING>
    ChannelConfig(int pin, fl::span<CRGB> leds, EOrder rgbOrder = RGB,
                  const ChannelOptions& options = ChannelOptions())
 FL_NOEXCEPT : ChannelConfig(makeClockless<TIMING>(pin), leds, rgbOrder, options) {}

    ChannelConfig(int pin, const ChipsetTimingConfig& timing, fl::span<CRGB> leds,
                  EOrder rgbOrder = RGB, const ChannelOptions& options = ChannelOptions()) FL_NOEXCEPT;
 
    // Copy constructor (needed because of variant)
    ChannelConfig(const ChannelConfig& other) FL_NOEXCEPT;
 
    // Move constructor (needed because of variant)
    ChannelConfig(ChannelConfig&& other) FL_NOEXCEPT;
 
    // Note: Assignment operators deleted because const members cannot be reassigned
    ChannelConfig& operator=(const ChannelConfig&) FL_NOEXCEPT = delete;
    ChannelConfig& operator=(ChannelConfig&&) FL_NOEXCEPT = delete;
 
    // ========== Accessors ==========

    const ChipsetVariant& getChipset() const FL_NOEXCEPT { return chipset; }

    bool isClockless() const FL_NOEXCEPT { return chipset.is<ClocklessChipset>(); }

    bool isSpi() const FL_NOEXCEPT { return chipset.is<SpiChipsetConfig>(); }

    const ClocklessChipset* getClocklessChipset() const FL_NOEXCEPT { return chipset.ptr<ClocklessChipset>(); }

    const SpiChipsetConfig* getSpiChipset() const FL_NOEXCEPT { return chipset.ptr<SpiChipsetConfig>(); }

    int getDataPin() const FL_NOEXCEPT;

    int getClockPin() const FL_NOEXCEPT;

    void setScreenMap(const fl::ScreenMap& map) FL_NOEXCEPT { mScreenMap = map; }

    const fl::ScreenMap& getScreenMap() const FL_NOEXCEPT { return mScreenMap; }

    bool hasScreenMap() const FL_NOEXCEPT { return mScreenMap.getLength() > 0; }
 
    // ========== Data Members ==========

    ChipsetVariant chipset;

    fl::span<CRGB> mLeds;

    EOrder rgb_order = RGB;

    ChannelOptions options;

    fl::ScreenMap mScreenMap;

    fl::optional<fl::string> mName;
};
 
FASTLED_SHARED_PTR_STRUCT(ChannelConfig);

template<typename Chipset>
struct ChannelConfigOf {
    ChannelConfigOf(const Chipset& chipset, fl::span<CRGB> leds,
                    EOrder rgbOrder = RGB,
                    const ChannelOptions& options = ChannelOptions()) FL_NOEXCEPT
        : chipset(chipset), mLeds(leds), rgb_order(rgbOrder), options(options) {}

    ChannelConfigOf(const fl::string& name, const Chipset& chipset,
                    fl::span<CRGB> leds, EOrder rgbOrder = RGB,
                    const ChannelOptions& options = ChannelOptions()) FL_NOEXCEPT
        : chipset(chipset), mLeds(leds), rgb_order(rgbOrder), options(options), mName(name) {}

    operator ChannelConfig() const FL_NOEXCEPT {
        ChannelConfig cfg(chipset, mLeds, rgb_order, options);
        cfg.mScreenMap = mScreenMap;
        if (mName.has_value()) {
            cfg.mName = mName;
        }
        return cfg;
    }

    ChannelConfig toErased() const FL_NOEXCEPT { return static_cast<ChannelConfig>(*this); }
 
    // ---- Data members (mirror ChannelConfig, but with typed `chipset`) ----

    Chipset chipset;

    fl::span<CRGB> mLeds;

    EOrder rgb_order = RGB;

    ChannelOptions options;

    fl::ScreenMap mScreenMap;

    fl::optional<fl::string> mName;
};

struct MultiChannelConfig {
    MultiChannelConfig() FL_NOEXCEPT = default;
    MultiChannelConfig(const MultiChannelConfig&) FL_NOEXCEPT = default;
    MultiChannelConfig(MultiChannelConfig&&) FL_NOEXCEPT = default;
 
    MultiChannelConfig(fl::span<ChannelConfigPtr> channels) FL_NOEXCEPT : mChannels(channels.begin(), channels.end()) {}
    MultiChannelConfig(fl::initializer_list<ChannelConfigPtr> channels) FL_NOEXCEPT : mChannels(channels.begin(), channels.end()) {}

    MultiChannelConfig(fl::span<ChannelConfig> channels) FL_NOEXCEPT;

    MultiChannelConfig(fl::initializer_list<ChannelConfig> channels) FL_NOEXCEPT;
 
    MultiChannelConfig& operator=(const MultiChannelConfig&) FL_NOEXCEPT = default;
    MultiChannelConfig& operator=(MultiChannelConfig&&) FL_NOEXCEPT = default;
    ~MultiChannelConfig() FL_NOEXCEPT = default;

    MultiChannelConfig& add(ChannelConfigPtr channel) FL_NOEXCEPT;

    fl::vector<ChannelConfigPtr> mChannels;
};
 
}