events.hpp

#pragma once
 
#include <launchdarkly/attribute_reference.hpp>
 
#include <chrono>
#include <cstddef>
#include <optional>
#include <string>
#include <unordered_map>
 
namespace launchdarkly::config::shared::builders {
template <typename T>
class EventsBuilder;
}
 
namespace launchdarkly::config::shared::built {
 
class Events final {
   public:
    template <typename SDK>
    friend class builders::EventsBuilder;
    Events(bool enabled,
           std::size_t capacity,
           std::chrono::milliseconds flush_interval,
           std::string path,
           bool all_attributes_private,
           AttributeReference::SetType private_attrs,
           std::chrono::milliseconds delivery_retry_delay,
           std::size_t flush_workers,
           std::optional<std::size_t> context_keys_cache_capacity);
 
    [[nodiscard]] bool Enabled() const;
 
    [[nodiscard]] std::size_t Capacity() const;
 
    [[nodiscard]] std::chrono::milliseconds FlushInterval() const;
 
    /*
     * If an event payload fails to be delivered and can be retried, how long
     * to wait before retrying.
     */
    [[nodiscard]] std::chrono::milliseconds DeliveryRetryDelay() const;
 
    [[nodiscard]] std::string const& Path() const;
 
    [[nodiscard]] bool AllAttributesPrivate() const;
 
    [[nodiscard]] AttributeReference::SetType const& PrivateAttributes() const;
 
    [[nodiscard]] std::size_t FlushWorkers() const;
 
    [[nodiscard]] std::optional<std::size_t> ContextKeysCacheCapacity() const;
 
   private:
    bool enabled_;
    std::size_t capacity_;
    std::chrono::milliseconds flush_interval_;
    std::string path_;
    bool all_attributes_private_;
    AttributeReference::SetType private_attributes_;
    std::chrono::milliseconds delivery_retry_delay_;
    std::size_t flush_workers_;
    std::optional<std::size_t> context_keys_cache_capacity_;
};
 
bool operator==(Events const& lhs, Events const& rhs);
 
}  // namespace launchdarkly::config::shared::built