hxflat_set.hpp

Go to the documentation of this file.

#pragma once
// SPDX-FileCopyrightText: © 2017-2026 Adrian Johnston.
// SPDX-License-Identifier: MIT
// This file is licensed under the MIT license found in the LICENSE.md file.

 
#include "libhatchet.h"
 
// HX_USE_MACROS_WITH_MODULE allows including macros alongside the module.
#if HX_USE_MACROS_WITH_MODULE
#error Header does not provide macros alone.
#endif
 
#include "hxallocator.hpp"
#include "hxrange.hpp"
#include "hxinitializer_list.hpp"
#include "hxkey.hpp"
 
HX_NS_BEGIN_
 
#if HX_CPLUSPLUS >= 202002L
template<typename T_>
concept hxflat_set_concept_ = requires(T_& x_) {
    sizeof(T_);
    x_.~T_();
};
#else
#define hxflat_set_concept_ typename
#endif

template<hxflat_set_concept_ key_t_,
    typename compare_t_=hxkey_less_t<key_t_>,
    bool multi_t_=true,
    hxsize_t capacity_=hxallocator_dynamic_capacity>
class hxflat_set : private hxallocator<key_t_, capacity_> {
public:
    using key_t = key_t_;
    using compare_t = compare_t_;

    using iterator = const key_t_*;

    using const_iterator = const key_t_*;

    explicit hxflat_set(void);

    hxflat_set(const hxflat_set& x_) noexcept;

    hxflat_set(hxflat_set&& x_) noexcept;

    hxflat_set(std::initializer_list<key_t_> x_) noexcept;

    ~hxflat_set(void) noexcept;
 
#if HX_CPLUSPLUS >= 202302L
    template<typename self_t_, typename callable_t_>
    hxattr_nodiscard auto and_then(
        this self_t_&& self_, const key_t_& key_, callable_t_&& callable_)
        -> hxremove_cvref_t<decltype(
            hxforward<callable_t_>(callable_)(
                hxforward_like<self_t_>(hxdeclval<const key_t_&>())))>;

    template<typename self_t_, typename callable_t_>
    hxattr_nodiscard auto and_then(
        this self_t_&& self_, const key_t_* it_, callable_t_&& callable_)
        -> hxremove_cvref_t<decltype(
            hxforward<callable_t_>(callable_)(
                hxforward_like<self_t_>(hxdeclval<const key_t_&>())))>;
#endif // HX_CPLUSPLUS >= 202302L

    void operator=(const hxflat_set& x_) noexcept;

    template<hxsize_t capacity_x_>
    void operator=(const hxflat_set<key_t_, compare_t_, multi_t_, capacity_x_>& x_) noexcept;

    void operator=(hxflat_set&& x_) noexcept;

    hxattr_nodiscard const key_t_* operator[](hxsize_t index_) const;

    template<hxsize_t capacity_x_>
    hxattr_nodiscard bool operator==(const hxflat_set<key_t_, compare_t_, multi_t_, capacity_x_>& x_) const;

    template<hxsize_t capacity_x_>
    hxattr_nodiscard bool operator<(const hxflat_set<key_t_, compare_t_, multi_t_, capacity_x_>& x_) const;

    template<hxrange_concept_ range_t_>
    void add_range(range_t_& range_) noexcept;

    template<hxrange_concept_ range_t_,
        hxenable_if_t<!hxis_lvalue_reference<range_t_>(), int> = 0>
    void add_range(range_t_&& range_) noexcept;

    const key_t_* begin(void) const { return this->data(); }

    hxattr_nodiscard hxsize_t capacity(void) const;

    const key_t_* cbegin(void) const { return this->data(); }

    const key_t_* cend(void) const { return m_end_; }

    void clear(void) noexcept;

    hxattr_nodiscard hxsize_t count(const key_t_& key_) const;

    using hxallocator<key_t_, capacity_>::data;

    template<typename... args_t_>
    const key_t_* emplace(args_t_&&... args_) noexcept;

    hxattr_nodiscard bool empty(void) const { return m_end_ == this->data(); }

    const key_t_* end(void) const { return m_end_; }

    hxsize_t erase(const key_t_& key_) noexcept;

    const key_t_* erase(const key_t_* it_) noexcept;

    hxattr_nodiscard const key_t_* find(const key_t_& key_) const;

    hxattr_nodiscard bool full(void) const { return m_end_ == this->data() + this->capacity(); }

    hxattr_nodiscard bool has_value(const key_t_& key_) const;

    const key_t_* insert(const key_t_& key_) noexcept;
 
    const key_t_* insert(key_t_&& key_) noexcept;

    hxattr_nodiscard const key_t_* keys(void) const noexcept;

    hxattr_nodiscard const key_t_* lower_bound(const key_t_& key_) const;

    hxattr_nodiscard hxsize_t max_size(void) const { return this->capacity(); }
 
#if HX_CPLUSPLUS >= 202302L
    template<typename self_t_, typename callable_t_>
    hxattr_nodiscard auto or_else(
        this self_t_&& self_, const key_t_& key_, callable_t_&& callable_)
        -> decltype(self_.end());

    template<typename self_t_, typename callable_t_>
    hxattr_nodiscard auto or_else(
        this self_t_&& self_, const key_t_* it_, callable_t_&& callable_)
        -> decltype(self_.end());
#endif // HX_CPLUSPLUS >= 202302L

    void reserve(hxsize_t cap_,
            hxsystem_allocator_t allocator_=hxsystem_allocator_current,
            hxalignment_t alignment_=hxalignment);

    hxattr_nodiscard hxsize_t size(void) const { return m_end_ - this->data(); }

    void swap(hxflat_set& x_) noexcept;

    hxattr_nodiscard const key_t_* upper_bound(const key_t_& key_) const;
 
#if HX_CPLUSPLUS >= 202302L
    template<typename self_t_, typename... args_t_>
    hxattr_nodiscard key_t_ value_or(
        this self_t_&& self_, const key_t_& key_, args_t_&&... args_);

    template<typename self_t_, typename... args_t_>
    hxattr_nodiscard key_t_ value_or(
        this self_t_&& self_, const key_t_* it_, args_t_&&... args_);
#endif // HX_CPLUSPLUS >= 202302L
 
private:
    template<hxflat_set_concept_, typename, bool, hxsize_t> friend class hxflat_set;
 
    template<typename key_u_>
    const key_t_* insert_at_(key_t_* it_, key_u_&& key_) noexcept;
 
    key_t_* m_end_;
};
 
#include "detail/hxflat_set.inl"
HX_NS_END_