flex_vector_transient.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/detail/rbts/rrbtree.hpp>
#include <immer/detail/rbts/rrbtree_iterator.hpp>
#include <immer/memory_policy.hpp>

namespace immer {

template <typename T,
          typename MemoryPolicy,
          detail::rbts::bits_t B,
          detail::rbts::bits_t BL>
class flex_vector;

template <typename T,
          typename MemoryPolicy,
          detail::rbts::bits_t B,
          detail::rbts::bits_t BL>
class vector_transient;

template <typename T,
          typename MemoryPolicy   = default_memory_policy,
          detail::rbts::bits_t B  = default_bits,
          detail::rbts::bits_t BL = detail::rbts::derive_bits_leaf<T, MemoryPolicy, B>>
class flex_vector_transient
    : MemoryPolicy::transience_t::owner
{
    using impl_t = detail::rbts::rrbtree<T, MemoryPolicy, B, BL>;
    using base_t = typename MemoryPolicy::transience_t::owner;
    using owner_t = typename MemoryPolicy::transience_t::owner;

public:
    static constexpr auto bits = B;
    static constexpr auto bits_leaf = BL;
    using memory_policy = MemoryPolicy;

    using value_type = T;
    using reference = const T&;
    using size_type = detail::rbts::size_t;
    using difference_type = std::ptrdiff_t;
    using const_reference = const T&;

    using iterator         = detail::rbts::rrbtree_iterator<T, MemoryPolicy, B, BL>;
    using const_iterator   = iterator;
    using reverse_iterator = std::reverse_iterator<iterator>;

    using persistent_type  = flex_vector<T, MemoryPolicy, B, BL>;

    flex_vector_transient() = default;

    flex_vector_transient(vector_transient<T, MemoryPolicy, B, BL> v)
        : base_t { std::move(static_cast<base_t&>(v)) }
        , impl_ { v.impl_.size, v.impl_.shift,
                  v.impl_.root->inc(), v.impl_.tail->inc() }
    {}

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

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

    reverse_iterator rbegin() const { return reverse_iterator{end()}; }

    reverse_iterator rend()   const { return reverse_iterator{begin()}; }

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

    bool empty() const { return impl_.size == 0; }

    reference operator[] (size_type index) const
    { return impl_.get(index); }

    reference at(size_type index) const
    { return impl_.get_check(index); }

    void push_back(value_type value)
    { impl_.push_back_mut(*this, std::move(value)); }

    void set(size_type index, value_type value)
    { impl_.assoc_mut(*this, index, std::move(value)); }

    template <typename FnT>
    void update(size_type index, FnT&& fn)
    { impl_.update_mut(*this, index, std::forward<FnT>(fn)); }

    void take(size_type elems)
    { impl_.take_mut(*this, elems); }

    void drop(size_type elems)
    { impl_.drop_mut(*this, elems); }

    persistent_type persistent() &
    {
        this->owner_t::operator=(owner_t{});
        return persistent_type{ impl_ };
    }
    persistent_type persistent() &&
    { return persistent_type{ std::move(impl_) }; }

    void append(flex_vector_transient& r)
    {
        r.owner_t::operator=(owner_t{});
        concat_mut_l(impl_, *this, r.impl_);
    }
    void append(flex_vector_transient&& r)
    { concat_mut_lr_l(impl_, *this, r.impl_, r); }

    void prepend(flex_vector_transient& l)
    {
        l.owner_t::operator=(owner_t{});
        concat_mut_r(l.impl_, impl_, *this);
    }
    void prepend(flex_vector_transient&& l)
    { concat_mut_lr_r(l.impl_, l, impl_, *this); }

private:
    friend persistent_type;

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

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

} // namespace immer