set.hpp

Go to the documentation of this file.

//
// immer: immutable data structures for C++
// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente
//
// This software is distributed under the Boost Software License, Version 1.0.
// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt
//

#pragma once

#include <immer/memory_policy.hpp>
#include <immer/detail/hamts/champ.hpp>
#include <immer/detail/hamts/champ_iterator.hpp>

#include <functional>

namespace immer {

template <typename T,
          typename Hash,
          typename Equal,
          typename MemoryPolicy,
          detail::hamts::bits_t B>
class set_transient;

template <typename T,
          typename Hash           = std::hash<T>,
          typename Equal          = std::equal_to<T>,
          typename MemoryPolicy   = default_memory_policy,
          detail::hamts::bits_t B = default_bits>
class set
{
    using impl_t = detail::hamts::champ<T, Hash, Equal, MemoryPolicy, B>;

public:
    using key_type = T;
    using value_type = T;
    using size_type = detail::hamts::size_t;
    using diference_type = std::ptrdiff_t;
    using hasher = Hash;
    using key_equal = Equal;
    using reference = const T&;
    using const_reference = const T&;

    using iterator         = detail::hamts::champ_iterator<T, Hash, Equal,
                                                         MemoryPolicy, B>;
    using const_iterator   = iterator;

    using transient_type   = set_transient<T, Hash, Equal, MemoryPolicy, B>;

    set() = default;

    iterator begin() const { return {impl_}; }

    iterator end() const { return {impl_, typename iterator::end_t{}}; }

    size_type size() const { return impl_.size; }

    size_type count(const T& value) const
    { return impl_.template get<detail::constantly<size_type, 1>,
                                detail::constantly<size_type, 0>>(value); }

    bool operator==(const set& other) const
    { return impl_.equals(other.impl_); }
    bool operator!=(const set& other) const
    { return !(*this == other); }

    set insert(T value) const
    { return impl_.add(std::move(value)); }

    set erase(const T& value) const
    { return impl_.sub(value); }

    transient_type transient() const&
    { return transient_type{ impl_ }; }
    transient_type transient() &&
    { return transient_type{ std::move(impl_) }; }

    // Semi-private
    const impl_t& impl() const { return impl_; }

private:
    friend transient_type;

    set(impl_t impl)
        : impl_(std::move(impl))
    {}

    impl_t impl_ = impl_t::empty();
};

} // namespace immer