source_manager.hpp

#pragma once
 
#include "../../data_interfaces/source/ifdv2_synchronizer.hpp"
#include "../../data_interfaces/source/ifdv2_synchronizer_factory.hpp"
 
#include <cstddef>
#include <memory>
#include <vector>
 
namespace launchdarkly::server_side::data_systems {
 
class SourceManager {
   public:
    explicit SourceManager(
        std::vector<std::unique_ptr<data_interfaces::IFDv2SynchronizerFactory>>
            factories);
 
    std::unique_ptr<data_interfaces::IFDv2Synchronizer> NextSynchronizer();
 
    void BlockCurrentSynchronizer();
 
    void ResetSourceIndex();
 
    void SwitchToFDv1Fallback();
 
    void SwitchBackToFDv2();
 
    [[nodiscard]] bool IsPrimeSynchronizer() const;
 
    [[nodiscard]] std::size_t AvailableSynchronizerCount() const;
 
    [[nodiscard]] std::size_t SynchronizerCount() const;
 
    [[nodiscard]] bool IsCurrentSynchronizerFDv1Fallback() const;
 
    SourceManager(SourceManager const&) = delete;
    SourceManager(SourceManager&&) = delete;
    SourceManager& operator=(SourceManager const&) = delete;
    SourceManager& operator=(SourceManager&&) = delete;
    ~SourceManager() = default;
 
   private:
    enum class State { kAvailable, kBlocked };
 
    struct SynchronizerFactoryWithState {
        std::unique_ptr<data_interfaces::IFDv2SynchronizerFactory> factory;
        State state = State::kAvailable;
        bool is_fdv1_fallback = false;
    };
 
    std::vector<SynchronizerFactoryWithState> synchronizers_;
    // Iteration cursor; -1 means "start at 0 on next call".
    int synchronizer_index_ = -1;
    // Index of the most recently returned factory; -1 if none.
    int current_factory_index_ = -1;
};
 
}  // namespace launchdarkly::server_side::data_systems