array.hpp

Go to the documentation of this file.

/*
 * Copyright 2018-2019, Intel Corporation
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in
 *       the documentation and/or other materials provided with the
 *       distribution.
 *
 *     * Neither the name of the copyright holder nor the names of its
 *       contributors may be used to endorse or promote products derived
 *       from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
#ifndef LIBPMEMOBJ_CPP_ARRAY_HPP
#define LIBPMEMOBJ_CPP_ARRAY_HPP
 
#include <algorithm>
#include <functional>
 
#include <libpmemobj++/detail/common.hpp>
#include <libpmemobj++/experimental/contiguous_iterator.hpp>
#include <libpmemobj++/experimental/slice.hpp>
#include <libpmemobj++/persistent_ptr.hpp>
#include <libpmemobj++/pext.hpp>
#include <libpmemobj.h>
 
namespace pmem
{
 
namespace obj
{
 
namespace experimental
{
 
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 = basic_contiguous_iterator<T>;
    using const_iterator = const_contiguous_iterator<T>;
    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>;
 
    /* Underlying array */
    typename standard_array_traits<T, N>::type _data;
 
    array() = default;
 
    array(const array &) = default;
 
    array(array &&) = default;
 
    array &
    operator=(const array &other)
    {
        detail::conditional_add_to_tx(this);
 
        std::copy(other.cbegin(), other.cend(), _get_data());
        return *this;
    }
 
    array &
    operator=(array &&other)
    {
        detail::conditional_add_to_tx(this);
 
        std::copy(other.cbegin(), other.cend(), _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);
 
        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];
    }
 
    reference operator[](size_type n)
    {
        detail::conditional_add_to_tx(_get_data() + n);
 
        return _get_data()[n];
    }
 
    const_reference operator[](size_type n) const
    {
        return _get_data()[n];
    }
 
    T *
    data()
    {
        detail::conditional_add_to_tx(this);
        return _get_data();
    }
 
    const T *
    data() 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());
        return _get_data()[0];
    }
 
    reference
    back()
    {
        detail::conditional_add_to_tx(&_get_data()[size() - 1]);
        return _get_data()[size() - 1];
    }
 
    const_reference
    front() const
    {
        return _get_data()[0];
    }
 
    const_reference
    back() const
    {
        return _get_data()[size() - 1];
    }
 
    slice<range_snapshotting_iterator<T>>
    range(size_type start, size_type n,
          size_type snapshot_size = std::numeric_limits<size_type>::max())
    {
        if (start + n > N)
            throw std::out_of_range("array::range");
 
        if (snapshot_size > n)
            snapshot_size = n;
 
        return {range_snapshotting_iterator<T>(_get_data() + start,
                               _get_data() + start, n,
                               snapshot_size),
            range_snapshotting_iterator<T>(_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)
    {
        detail::conditional_add_to_tx(this);
        std::fill(_get_data(), _get_data() + size(), value);
    }
 
    template <std::size_t Size = N>
    typename std::enable_if<Size != 0>::type
    swap(array &other)
    {
        detail::conditional_add_to_tx(this);
        detail::conditional_add_to_tx(&other);
 
        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);
    }
};
 
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::experimental::array<T, N>::const_iterator
cbegin(const pmem::obj::experimental::array<T, N> &a)
{
    return a.cbegin();
}
 
template <typename T, std::size_t N>
typename pmem::obj::experimental::array<T, N>::const_iterator
cend(const pmem::obj::experimental::array<T, N> &a)
{
    return a.cend();
}
 
template <typename T, std::size_t N>
typename pmem::obj::experimental::array<T, N>::const_reverse_iterator
crbegin(const pmem::obj::experimental::array<T, N> &a)
{
    return a.crbegin();
}
 
template <typename T, std::size_t N>
typename pmem::obj::experimental::array<T, N>::const_reverse_iterator
crend(const pmem::obj::experimental::array<T, N> &a)
{
    return a.crend();
}
 
template <typename T, std::size_t N>
typename pmem::obj::experimental::array<T, N>::iterator
begin(pmem::obj::experimental::array<T, N> &a)
{
    return a.begin();
}
 
template <typename T, std::size_t N>
typename pmem::obj::experimental::array<T, N>::iterator
end(pmem::obj::experimental::array<T, N> &a)
{
    return a.end();
}
 
template <typename T, std::size_t N>
typename pmem::obj::experimental::array<T, N>::reverse_iterator
rbegin(pmem::obj::experimental::array<T, N> &a)
{
    return a.rbegin();
}
 
template <typename T, std::size_t N>
typename pmem::obj::experimental::array<T, N>::reverse_iterator
rend(pmem::obj::experimental::array<T, N> &a)
{
    return a.rend();
}
 
template <typename T, size_t N>
inline void
swap(pmem::obj::experimental::array<T, N> &lhs,
     pmem::obj::experimental::array<T, N> &rhs)
{
    lhs.swap(rhs);
}
 
template <size_t I, typename T, size_t N>
T &
get(pmem::obj::experimental::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::experimental::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::experimental::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::experimental::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 experimental */
 
} /* namespace obj */
 
} /* namespace pmem */
 
#endif /* LIBPMEMOBJ_CPP_ARRAY_HPP */