self_relative_ptr.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-3-Clause
/* Copyright 2020, Intel Corporation */
 
#ifndef LIBPMEMOBJ_CPP_SELF_RELATIVE_PTR_HPP
#define LIBPMEMOBJ_CPP_SELF_RELATIVE_PTR_HPP
 
#include <libpmemobj++/detail/specialization.hpp>
#include <libpmemobj++/experimental/self_relative_ptr_base.hpp>
#include <libpmemobj++/persistent_ptr.hpp>
#include <type_traits>
 
namespace pmem
{
namespace obj
{
namespace experimental
{
 
template <typename T>
class self_relative_ptr : public self_relative_ptr_base {
public:
    using base_type = self_relative_ptr_base;
    using this_type = self_relative_ptr;
    using element_type = typename pmem::detail::sp_element<T>::type;
 
    using iterator_category = std::random_access_iterator_tag;
 
    using difference_type = typename base_type::difference_type;
 
    using value_type = T;
 
    using reference = T &;
 
    /*
     * Constructors
     */
 
    constexpr self_relative_ptr() noexcept = default;
 
    constexpr self_relative_ptr(std::nullptr_t) noexcept
        : self_relative_ptr_base()
    {
    }
 
    self_relative_ptr(element_type *ptr) noexcept
        : self_relative_ptr_base(self_offset(ptr))
    {
    }
 
    self_relative_ptr(persistent_ptr<T> ptr) noexcept
        : self_relative_ptr_base(self_offset(ptr.get()))
    {
    }
 
    self_relative_ptr(PMEMoid oid) noexcept
        : self_relative_ptr_base(self_offset(
              static_cast<element_type *>(pmemobj_direct(oid))))
    {
    }
 
    self_relative_ptr(const self_relative_ptr &ptr) noexcept
        : self_relative_ptr_base(ptr)
    {
    }
 
    template <
        typename U,
        typename = typename std::enable_if<
            !std::is_same<
                typename std::remove_cv<T>::type,
                typename std::remove_cv<U>::type>::value &&
                !std::is_void<U>::value,
            decltype(static_cast<T *>(std::declval<U *>()))>::type>
    self_relative_ptr(self_relative_ptr<U> const &r) noexcept
        : self_relative_ptr_base(self_offset(static_cast<T *>(r.get())))
    {
    }
 
    ~self_relative_ptr()
    {
        verify_type();
    }
 
    inline element_type *
    get() const noexcept
    {
        return static_cast<element_type *>(
            self_relative_ptr_base::to_void_pointer());
    }
 
    persistent_ptr<T>
    to_persistent_ptr() const
    {
        return persistent_ptr<T>{this->get()};
    }
 
    /*
     * Operators
     */
 
    explicit operator bool() const noexcept
    {
        return !is_null();
    }
 
    operator persistent_ptr<T>() const
    {
        return to_persistent_ptr();
    }
 
    typename pmem::detail::sp_dereference<T>::type operator*() const
        noexcept
    {
        return *(this->get());
    }
 
    typename pmem::detail::sp_member_access<T>::type operator->() const
        noexcept
    {
        return this->get();
    }
 
    template <typename = typename std::enable_if<!std::is_void<T>::value>>
    typename pmem::detail::sp_array_access<T>::type
    operator[](difference_type i) const noexcept
    {
        assert(i >= 0 &&
               (i < pmem::detail::sp_extent<T>::value ||
            pmem::detail::sp_extent<T>::value == 0) &&
               "persistent array index out of bounds");
 
        return this->get()[i];
    }
 
    self_relative_ptr &
    operator=(const self_relative_ptr &r)
    {
        this->base_type::operator=(r);
        return *this;
    }
 
    template <typename Y,
          typename = typename std::enable_if<
              std::is_convertible<Y *, T *>::value>::type>
    self_relative_ptr<T> &
    operator=(self_relative_ptr<Y> const &r)
    {
        this_type(r).swap(*this);
        return *this;
    }
 
    self_relative_ptr &operator=(std::nullptr_t)
    {
        detail::conditional_add_to_tx(this);
        this->offset = self_offset(nullptr);
        return *this;
    }
 
    inline self_relative_ptr<T> &
    operator++()
    {
        detail::conditional_add_to_tx(this);
        this->offset += static_cast<difference_type>(sizeof(T));
 
        return *this;
    }
 
    inline self_relative_ptr<T>
    operator++(int)
    {
        auto copy = *this;
        ++(*this);
 
        return copy;
    }
 
    inline self_relative_ptr<T> &
    operator--()
    {
        detail::conditional_add_to_tx(this);
        this->offset -= static_cast<difference_type>(sizeof(T));
 
        return *this;
    }
 
    inline self_relative_ptr<T>
    operator--(int)
    {
        auto copy = *this;
        --(*this);
 
        return copy;
    }
 
    inline self_relative_ptr<T> &
    operator+=(std::ptrdiff_t s)
    {
        detail::conditional_add_to_tx(this);
        this->offset += s * static_cast<difference_type>(sizeof(T));
        return *this;
    }
 
    inline self_relative_ptr<T> &
    operator-=(std::ptrdiff_t s)
    {
        detail::conditional_add_to_tx(this);
        this->offset -= s * static_cast<difference_type>(sizeof(T));
        return *this;
    }
 
protected:
    void
    verify_type()
    {
        static_assert(!std::is_polymorphic<element_type>::value,
                  "Polymorphic types are not supported");
    }
 
private:
    difference_type
    self_offset(element_type *ptr) const noexcept
    {
        return base_type::pointer_to_offset(static_cast<void *>(ptr));
    }
};
 
template <class T>
inline void
swap(self_relative_ptr<T> &a, self_relative_ptr<T> &b)
{
    a.swap(b);
}
 
template <typename T, typename Y>
inline bool
operator==(self_relative_ptr<T> const &lhs,
       self_relative_ptr<Y> const &rhs) noexcept
{
    return lhs.to_byte_pointer() == rhs.to_byte_pointer();
}
 
template <typename T, typename Y>
inline bool
operator!=(self_relative_ptr<T> const &lhs,
       self_relative_ptr<Y> const &rhs) noexcept
{
    return !(lhs == rhs);
}
 
template <typename T>
inline bool
operator==(self_relative_ptr<T> const &lhs, std::nullptr_t) noexcept
{
    return !bool(lhs);
}
 
template <typename T>
inline bool
operator==(std::nullptr_t, self_relative_ptr<T> const &lhs) noexcept
{
    return !bool(lhs);
}
 
template <typename T>
inline bool
operator!=(self_relative_ptr<T> const &lhs, std::nullptr_t) noexcept
{
    return bool(lhs);
}
 
template <typename T>
inline bool
operator!=(std::nullptr_t, self_relative_ptr<T> const &lhs) noexcept
{
    return bool(lhs);
}
 
template <typename T, typename Y>
inline bool
operator<(self_relative_ptr<T> const &lhs,
      self_relative_ptr<Y> const &rhs) noexcept
{
    return lhs.to_byte_pointer() < rhs.to_byte_pointer();
}
 
template <typename T, typename Y>
inline bool
operator<=(self_relative_ptr<T> const &lhs,
       self_relative_ptr<Y> const &rhs) noexcept
{
    return !(rhs < lhs);
}
 
template <typename T, typename Y>
inline bool
operator>(self_relative_ptr<T> const &lhs,
      self_relative_ptr<Y> const &rhs) noexcept
{
    return (rhs < lhs);
}
 
template <typename T, typename Y>
inline bool
operator>=(self_relative_ptr<T> const &lhs,
       self_relative_ptr<Y> const &rhs) noexcept
{
    return !(lhs < rhs);
}
 
/* nullptr comparisons */
 
template <typename T>
inline bool
operator<(self_relative_ptr<T> const &lhs, std::nullptr_t) noexcept
{
    return std::less<typename self_relative_ptr<T>::element_type *>()(
        lhs.get(), nullptr);
}
 
template <typename T>
inline bool
operator<(std::nullptr_t, self_relative_ptr<T> const &rhs) noexcept
{
    return std::less<typename self_relative_ptr<T>::element_type *>()(
        nullptr, rhs.get());
}
 
template <typename T>
inline bool
operator<=(self_relative_ptr<T> const &lhs, std::nullptr_t) noexcept
{
    return !(nullptr < lhs);
}
 
template <typename T>
inline bool
operator<=(std::nullptr_t, self_relative_ptr<T> const &rhs) noexcept
{
    return !(rhs < nullptr);
}
 
template <typename T>
inline bool
operator>(self_relative_ptr<T> const &lhs, std::nullptr_t) noexcept
{
    return nullptr < lhs;
}
 
template <typename T>
inline bool
operator>(std::nullptr_t, self_relative_ptr<T> const &rhs) noexcept
{
    return rhs < nullptr;
}
 
template <typename T>
inline bool
operator>=(self_relative_ptr<T> const &lhs, std::nullptr_t) noexcept
{
    return !(lhs < nullptr);
}
 
template <typename T>
inline bool
operator>=(std::nullptr_t, self_relative_ptr<T> const &rhs) noexcept
{
    return !(nullptr < rhs);
}
 
template <typename T>
inline self_relative_ptr<T>
operator+(self_relative_ptr<T> const &lhs, std::ptrdiff_t s)
{
    self_relative_ptr<T> ptr = lhs;
    ptr += s;
    return ptr;
}
 
template <typename T>
inline self_relative_ptr<T>
operator-(self_relative_ptr<T> const &lhs, std::ptrdiff_t s)
{
    self_relative_ptr<T> ptr = lhs;
    ptr -= s;
    return ptr;
}
 
template <typename T, typename Y,
      typename = typename std::enable_if<
          std::is_same<typename std::remove_cv<T>::type,
                   typename std::remove_cv<Y>::type>::value>>
inline ptrdiff_t
operator-(self_relative_ptr<T> const &lhs, self_relative_ptr<Y> const &rhs)
{
    return self_relative_ptr_base::distance_between(rhs, lhs) /
        static_cast<ptrdiff_t>(sizeof(T));
}
 
template <typename T>
std::ostream &
operator<<(std::ostream &os, self_relative_ptr<T> const &ptr)
{
    os << ptr.to_void_pointer();
    return os;
}
 
} /* namespace experimental */
 
} /* namespace obj */
 
} /* namespace pmem */
 
#endif /* LIBPMEMOBJ_CPP_SELF_RELATIVE_PTR_HPP */