array.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-3-Clause
/* Copyright 2018-2021, Intel Corporation */
 
#ifndef LIBPMEMOBJ_CPP_ARRAY_HPP
#define LIBPMEMOBJ_CPP_ARRAY_HPP
 
#include <algorithm>
#include <functional>
#include <initializer_list>
 
#include <libpmemobj++/container/detail/contiguous_iterator.hpp>
#include <libpmemobj++/detail/common.hpp>
#include <libpmemobj++/persistent_ptr.hpp>
#include <libpmemobj++/pext.hpp>
#include <libpmemobj++/slice.hpp>
#include <libpmemobj++/transaction.hpp>
#include <libpmemobj++/utils.hpp>
#include <libpmemobj/base.h>
 
namespace pmem
{
 
namespace obj
{
 
template <typename T, std::size_t N>
struct array {
 
    template <typename Y, std::size_t M>
    struct standard_array_traits {
        using type = Y[N];
    };
 
    /* zero-sized array support */
    template <typename Y>
    struct standard_array_traits<Y, 0> {
        struct _alignment_struct {
            Y _data[1];
        };
 
        struct alignas(_alignment_struct) type {
            char _data[sizeof(_alignment_struct)];
        };
    };
 
    /* Member types */
    using value_type = T;
    using pointer = value_type *;
    using const_pointer = const value_type *;
    using reference = value_type &;
    using const_reference = const value_type &;
    using iterator = pmem::detail::basic_contiguous_iterator<T>;
    using const_iterator = const_pointer;
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;
    using reverse_iterator = std::reverse_iterator<iterator>;
    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
    using range_snapshotting_iterator =
        pmem::detail::range_snapshotting_iterator<T>;
 
    /* Underlying array */
    typename standard_array_traits<T, N>::type _data;
 
    array() = default;
 
    array(const array &) = default;
 
    array(array &&) = default;
 
#if __cplusplus > 201703L
    array(std::initializer_list<T> list)
    {
        if constexpr (N > 0) {
            size_t i = 0;
            for (auto &v : list) {
                (*this)[i] = v;
                i++;
            }
        }
    }
#endif /* __cplusplus */
 
    array &
    operator=(const array &other)
    {
        /*
         * _get_pool should be called before self assignment check to
         * maintain the same behaviour for all arguments.
         */
        auto pop = _get_pool();
 
        if (this == &other)
            return *this;
 
        flat_transaction::run(pop, [&] {
            detail::conditional_add_to_tx(
                this, 1, POBJ_XADD_ASSUME_INITIALIZED);
            std::copy(other.cbegin(), other.cend(), _get_data());
        });
 
        return *this;
    }
 
    array &
    operator=(array &&other)
    {
        /*
         * _get_pool should be called before self assignment check to
         * maintain the same behaviour for all arguments.
         */
        auto pop = _get_pool();
 
        if (this == &other)
            return *this;
 
        flat_transaction::run(pop, [&] {
            detail::conditional_add_to_tx(
                this, 1, POBJ_XADD_ASSUME_INITIALIZED);
            detail::conditional_add_to_tx(
                &other, 1, POBJ_XADD_ASSUME_INITIALIZED);
            std::move(other._get_data(), other._get_data() + size(),
                  _get_data());
        });
 
        return *this;
    }
 
    reference
    at(size_type n)
    {
        if (n >= N)
            throw std::out_of_range("array::at");
 
        detail::conditional_add_to_tx(_get_data() + n, 1,
                          POBJ_XADD_ASSUME_INITIALIZED);
 
        return _get_data()[n];
    }
 
    const_reference
    at(size_type n) const
    {
        if (n >= N)
            throw std::out_of_range("array::at");
 
        return _get_data()[n];
    }
 
    const_reference
    const_at(size_type n) const
    {
        if (n >= N)
            throw std::out_of_range("array::const_at");
 
        return _get_data()[n];
    }
 
    reference operator[](size_type n)
    {
        detail::conditional_add_to_tx(_get_data() + n, 1,
                          POBJ_XADD_ASSUME_INITIALIZED);
 
        return _get_data()[n];
    }
 
    const_reference operator[](size_type n) const
    {
        return _get_data()[n];
    }
 
    T *
    data()
    {
        detail::conditional_add_to_tx(this, 1,
                          POBJ_XADD_ASSUME_INITIALIZED);
        return _get_data();
    }
 
    const T *
    data() const noexcept
    {
        return _get_data();
    }
 
    const T *
    cdata() const noexcept
    {
        return _get_data();
    }
 
    iterator
    begin()
    {
        return iterator(_get_data());
    }
 
    iterator
    end()
    {
        return iterator(_get_data() + size());
    }
 
    const_iterator
    begin() const noexcept
    {
        return const_iterator(_get_data());
    }
 
    const_iterator
    cbegin() const noexcept
    {
        return const_iterator(_get_data());
    }
 
    const_iterator
    end() const noexcept
    {
        return const_iterator(_get_data() + size());
    }
 
    const_iterator
    cend() const noexcept
    {
        return const_iterator(_get_data() + size());
    }
 
    reverse_iterator
    rbegin()
    {
        return reverse_iterator(iterator(_get_data() + size()));
    }
 
    reverse_iterator
    rend()
    {
        return reverse_iterator(iterator(_get_data()));
    }
 
    const_reverse_iterator
    rbegin() const noexcept
    {
        return const_reverse_iterator(cend());
    }
 
    const_reverse_iterator
    crbegin() const noexcept
    {
        return const_reverse_iterator(cend());
    }
 
    const_reverse_iterator
    rend() const noexcept
    {
        return const_reverse_iterator(cbegin());
    }
 
    const_reverse_iterator
    crend() const noexcept
    {
        return const_reverse_iterator(cbegin());
    }
 
    reference
    front()
    {
        detail::conditional_add_to_tx(_get_data(), 1,
                          POBJ_XADD_ASSUME_INITIALIZED);
        return _get_data()[0];
    }
 
    reference
    back()
    {
        detail::conditional_add_to_tx(&_get_data()[size() - 1], 1,
                          POBJ_XADD_ASSUME_INITIALIZED);
        return _get_data()[size() - 1];
    }
 
    const_reference
    front() const
    {
        return _get_data()[0];
    }
 
    const_reference
    cfront() const
    {
        return _get_data()[0];
    }
 
    const_reference
    back() const
    {
        return _get_data()[size() - 1];
    }
 
    const_reference
    cback() const
    {
        return _get_data()[size() - 1];
    }
 
    slice<pointer>
    range(size_type start, size_type n)
    {
        if (start + n > N)
            throw std::out_of_range("array::range");
 
        detail::conditional_add_to_tx(_get_data() + start, n,
                          POBJ_XADD_ASSUME_INITIALIZED);
 
        return {_get_data() + start, _get_data() + start + n};
    }
 
    slice<range_snapshotting_iterator>
    range(size_type start, size_type n, size_type snapshot_size)
    {
        if (start + n > N)
            throw std::out_of_range("array::range");
 
        if (snapshot_size > n)
            snapshot_size = n;
 
        return {range_snapshotting_iterator(_get_data() + start,
                            _get_data() + start, n,
                            snapshot_size),
            range_snapshotting_iterator(_get_data() + start + n,
                            _get_data() + start, n,
                            snapshot_size)};
    }
 
    slice<const_iterator>
    range(size_type start, size_type n) const
    {
        if (start + n > N)
            throw std::out_of_range("array::range");
 
        return {const_iterator(_get_data() + start),
            const_iterator(_get_data() + start + n)};
    }
 
    slice<const_iterator>
    crange(size_type start, size_type n) const
    {
        if (start + n > N)
            throw std::out_of_range("array::crange");
 
        return {const_iterator(_get_data() + start),
            const_iterator(_get_data() + start + n)};
    }
 
    constexpr size_type
    size() const noexcept
    {
        return N;
    }
 
    constexpr size_type
    max_size() const noexcept
    {
        return N;
    }
 
    constexpr bool
    empty() const noexcept
    {
        return size() == 0;
    }
 
    void
    fill(const_reference value)
    {
        auto pop = _get_pool();
 
        flat_transaction::run(pop, [&] {
            detail::conditional_add_to_tx(
                this, 1, POBJ_XADD_ASSUME_INITIALIZED);
            std::fill(_get_data(), _get_data() + size(), value);
        });
    }
 
    template <std::size_t Size = N>
    typename std::enable_if<Size != 0>::type
    swap(array &other)
    {
        /*
         * _get_pool should be called before self assignment check to
         * maintain the same behaviour for all arguments.
         */
        auto pop = _get_pool();
 
        if (this == &other)
            return;
 
        flat_transaction::run(pop, [&] {
            detail::conditional_add_to_tx(
                this, 1, POBJ_XADD_ASSUME_INITIALIZED);
            detail::conditional_add_to_tx(
                &other, 1, POBJ_XADD_ASSUME_INITIALIZED);
 
            std::swap_ranges(_get_data(), _get_data() + size(),
                     other._get_data());
        });
    }
 
    template <std::size_t Size = N>
    typename std::enable_if<Size == 0>::type
    swap(array &other)
    {
        static_assert(!std::is_const<T>::value,
                  "cannot swap zero-sized array of type 'const T'");
    }
 
private:
    template <std::size_t Size = N>
    typename std::enable_if<Size != 0, T *>::type
    _get_data()
    {
        return this->_data;
    }
 
    template <std::size_t Size = N>
    typename std::enable_if<Size != 0, const T *>::type
    _get_data() const
    {
        return this->_data;
    }
 
    template <std::size_t Size = N>
    typename std::enable_if<Size == 0, T *>::type
    _get_data()
    {
        return reinterpret_cast<T *>(&this->_data);
    }
 
    template <std::size_t Size = N>
    typename std::enable_if<Size == 0, const T *>::type
    _get_data() const
    {
        return reinterpret_cast<const T *>(&this->_data);
    }
 
    pool_base
    _get_pool() const
    {
        return pmem::obj::pool_by_vptr(this);
    }
};
 
template <typename T, std::size_t N>
inline bool
operator==(const array<T, N> &lhs, const array<T, N> &rhs)
{
    return std::equal(lhs.cbegin(), lhs.cend(), rhs.cbegin());
}
 
template <typename T, std::size_t N>
inline bool
operator!=(const array<T, N> &lhs, const array<T, N> &rhs)
{
    return !(lhs == rhs);
}
 
template <typename T, std::size_t N>
inline bool
operator<(const array<T, N> &lhs, const array<T, N> &rhs)
{
    return std::lexicographical_compare(lhs.cbegin(), lhs.cend(),
                        rhs.cbegin(), rhs.cend());
}
 
template <typename T, std::size_t N>
inline bool
operator>(const array<T, N> &lhs, const array<T, N> &rhs)
{
    return rhs < lhs;
}
 
template <typename T, std::size_t N>
inline bool
operator>=(const array<T, N> &lhs, const array<T, N> &rhs)
{
    return !(lhs < rhs);
}
 
template <typename T, std::size_t N>
inline bool
operator<=(const array<T, N> &lhs, const array<T, N> &rhs)
{
    return !(lhs > rhs);
}
 
template <typename T, std::size_t N>
typename pmem::obj::array<T, N>::const_iterator
cbegin(const pmem::obj::array<T, N> &a)
{
    return a.cbegin();
}
 
template <typename T, std::size_t N>
typename pmem::obj::array<T, N>::const_iterator
cend(const pmem::obj::array<T, N> &a)
{
    return a.cend();
}
 
template <typename T, std::size_t N>
typename pmem::obj::array<T, N>::const_reverse_iterator
crbegin(const pmem::obj::array<T, N> &a)
{
    return a.crbegin();
}
 
template <typename T, std::size_t N>
typename pmem::obj::array<T, N>::const_reverse_iterator
crend(const pmem::obj::array<T, N> &a)
{
    return a.crend();
}
 
template <typename T, std::size_t N>
typename pmem::obj::array<T, N>::iterator
begin(pmem::obj::array<T, N> &a)
{
    return a.begin();
}
 
template <typename T, std::size_t N>
typename pmem::obj::array<T, N>::const_iterator
begin(const pmem::obj::array<T, N> &a)
{
    return a.begin();
}
 
template <typename T, std::size_t N>
typename pmem::obj::array<T, N>::iterator
end(pmem::obj::array<T, N> &a)
{
    return a.end();
}
 
template <typename T, std::size_t N>
typename pmem::obj::array<T, N>::const_iterator
end(const pmem::obj::array<T, N> &a)
{
    return a.end();
}
 
template <typename T, std::size_t N>
typename pmem::obj::array<T, N>::reverse_iterator
rbegin(pmem::obj::array<T, N> &a)
{
    return a.rbegin();
}
 
template <typename T, std::size_t N>
typename pmem::obj::array<T, N>::const_reverse_iterator
rbegin(const pmem::obj::array<T, N> &a)
{
    return a.rbegin();
}
 
template <typename T, std::size_t N>
typename pmem::obj::array<T, N>::reverse_iterator
rend(pmem::obj::array<T, N> &a)
{
    return a.rend();
}
 
template <typename T, std::size_t N>
typename pmem::obj::array<T, N>::const_reverse_iterator
rend(const pmem::obj::array<T, N> &a)
{
    return a.rend();
}
 
template <typename T, size_t N>
inline void
swap(pmem::obj::array<T, N> &lhs, pmem::obj::array<T, N> &rhs)
{
    lhs.swap(rhs);
}
 
template <size_t I, typename T, size_t N>
T &
get(pmem::obj::array<T, N> &a)
{
    static_assert(I < N,
              "Index out of bounds in std::get<> (pmem::obj::array)");
    return a.at(I);
}
 
template <size_t I, typename T, size_t N>
T &&
get(pmem::obj::array<T, N> &&a)
{
    static_assert(I < N,
              "Index out of bounds in std::get<> (pmem::obj::array)");
    return std::move(a.at(I));
}
 
template <size_t I, typename T, size_t N>
const T &
get(const pmem::obj::array<T, N> &a) noexcept
{
    static_assert(I < N,
              "Index out of bounds in std::get<> (pmem::obj::array)");
    return a.at(I);
}
 
template <size_t I, typename T, size_t N>
const T &&
get(const pmem::obj::array<T, N> &&a) noexcept
{
    static_assert(I < N,
              "Index out of bounds in std::get<> (pmem::obj::array)");
    return std::move(a.at(I));
}
 
} /* namespace obj */
 
} /* namespace pmem */
 
#endif /* LIBPMEMOBJ_CPP_ARRAY_HPP */