persistent_ptr.hpp

Go to the documentation of this file.

/*
 * Copyright 2015-2016, 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 PMEMOBJ_PERSISTENT_PTR_HPP
#define PMEMOBJ_PERSISTENT_PTR_HPP

#include <cassert>
#include <memory>
#include <ostream>

#include "libpmemobj++/detail/common.hpp"
#include "libpmemobj++/detail/specialization.hpp"
#include "libpmemobj++/pool.hpp"

namespace nvml
{

namespace obj
{
template <typename T>
class pool;

template <typename T>
class persistent_ptr {
    template <typename Y>
    friend class persistent_ptr;

    typedef persistent_ptr<T> this_type;

public:
    typedef typename nvml::detail::sp_element<T>::type element_type;

    persistent_ptr() : oid(OID_NULL)
    {
        verify_type();
    }

    /*
     * Curly braces initialization is not used because the
     * PMEMoid is a plain C (POD) type and we can't add a default
     * constructor in there.
     */

    persistent_ptr(std::nullptr_t) noexcept : oid(OID_NULL)
    {
        verify_type();
    }

    persistent_ptr(PMEMoid oid) noexcept : oid(oid)
    {
        verify_type();
    }

    template <typename Y,
          typename = typename std::enable_if<
              std::is_convertible<Y *, T *>::value>::type>
    persistent_ptr(const persistent_ptr<Y> &r) noexcept : oid(r.oid)
    {
        verify_type();
    }

    /*
     * Copy constructor.
     *
     * @param r Persistent pointer to the same type.
     */
    persistent_ptr(const persistent_ptr &r) noexcept : oid(r.oid)
    {
        verify_type();
    }

    persistent_ptr(persistent_ptr &&r) noexcept : oid(std::move(r.oid))
    {
        verify_type();
    }

    persistent_ptr &
    operator=(persistent_ptr &&r)
    {
        detail::conditional_add_to_tx(this);
        this->oid = std::move(r.oid);

        return *this;
    }

    persistent_ptr &
    operator=(const persistent_ptr &r)
    {
        detail::conditional_add_to_tx(this);
        this_type(r).swap(*this);

        return *this;
    }

    template <typename Y,
          typename = typename std::enable_if<
              std::is_convertible<Y *, T *>::value>::type>
    persistent_ptr &
    operator=(const persistent_ptr<Y> &r)
    {
        detail::conditional_add_to_tx(this);
        this_type(r).swap(*this);

        return *this;
    }

    typename nvml::detail::sp_dereference<T>::type operator*() const
        noexcept
    {
        return *get();
    }

    typename nvml::detail::sp_member_access<T>::type operator->() const
        noexcept
    {
        return get();
    }

    typename nvml::detail::sp_array_access<T>::type
    operator[](std::ptrdiff_t i) const noexcept
    {
        assert(i >= 0 && (i < nvml::detail::sp_extent<T>::value ||
                  nvml::detail::sp_extent<T>::value == 0) &&
               "persistent array index out of bounds");

        return get()[i];
    }

    element_type *
    get() const noexcept
    {
        return (element_type *)pmemobj_direct(this->oid);
    }

    void
    swap(persistent_ptr &other) noexcept
    {
        std::swap(this->oid, other.oid);
    }

    /*
     * Bool conversion operator.
     */
    explicit operator bool() const noexcept
    {
        return get() != nullptr;
    }

    const PMEMoid &
    raw() const noexcept
    {
        return this->oid;
    }

    PMEMoid *
    raw_ptr() noexcept
    {
        return &(this->oid);
    }

    inline persistent_ptr<T> &operator++()
    {
        detail::conditional_add_to_tx(this);
        this->oid.off += sizeof(T);

        return *this;
    }

    inline persistent_ptr<T> operator++(int)
    {
        PMEMoid noid = this->oid;
        ++(*this);

        return persistent_ptr<T>(noid);
    }

    inline persistent_ptr<T> &operator--()
    {
        detail::conditional_add_to_tx(this);
        this->oid.off -= sizeof(T);

        return *this;
    }

    inline persistent_ptr<T> operator--(int)
    {
        PMEMoid noid = this->oid;
        --(*this);

        return persistent_ptr<T>(noid);
    }

    inline persistent_ptr<T> &
    operator+=(std::ptrdiff_t s)
    {
        detail::conditional_add_to_tx(this);
        this->oid.off += s * sizeof(T);

        return *this;
    }

    inline persistent_ptr<T> &
    operator-=(std::ptrdiff_t s)
    {
        detail::conditional_add_to_tx(this);
        this->oid.off -= s * sizeof(T);

        return *this;
    }

    void
    persist(pool_base &pop)
    {
        pop.persist(this->get(), sizeof(T));
    }

    void
    persist(void)
    {
        pmemobjpool *pop = pmemobj_pool_by_oid(this->raw());

        if (pop == nullptr)
            throw pool_error("Cannot get pool from "
                     "persistent pointer");

        pmemobj_persist(pop, this->get(), sizeof(T));
    }

    void
    flush(pool_base &pop)
    {
        pop.flush(this->get(), sizeof(T));
    }

    void
    flush(void)
    {
        pmemobjpool *pop = pmemobj_pool_by_oid(this->raw());

        if (pop == nullptr)
            throw pool_error("Cannot get pool from "
                     "persistent pointer");

        pmemobj_flush(pop, this->get(), sizeof(T));
    }

private:
    /* The underlying PMEMoid of the held object. */
    PMEMoid oid;

    /*
     * C++ persistent memory support has following type limitations:
     * en.cppreference.com/w/cpp/types/is_polymorphic
     * en.cppreference.com/w/cpp/types/is_default_constructible
     * en.cppreference.com/w/cpp/types/is_destructible
     */
    void
    verify_type()
    {
        static_assert(!std::is_polymorphic<element_type>::value,
                  "Polymorphic types are not supported");
    }
};

template <class T>
inline void
swap(persistent_ptr<T> &a, persistent_ptr<T> &b) noexcept
{
    a.swap(b);
}

template <typename T, typename Y>
inline bool
operator==(const persistent_ptr<T> &lhs, const persistent_ptr<Y> &rhs) noexcept
{
    return OID_EQUALS(lhs.raw(), rhs.raw());
}

template <typename T, typename Y>
inline bool
operator!=(const persistent_ptr<T> &lhs, const persistent_ptr<Y> &rhs) noexcept
{
    return !(lhs == rhs);
}

template <typename T>
inline bool
operator==(const persistent_ptr<T> &lhs, std::nullptr_t) noexcept
{
    return lhs.get() == nullptr;
}

template <typename T>
inline bool
operator==(std::nullptr_t, const persistent_ptr<T> &lhs) noexcept
{
    return lhs.get() == nullptr;
}

template <typename T>
inline bool
operator!=(const persistent_ptr<T> &lhs, std::nullptr_t) noexcept
{
    return lhs.get() != nullptr;
}

template <typename T>
inline bool
operator!=(std::nullptr_t, const persistent_ptr<T> &lhs) noexcept
{
    return lhs.get() != nullptr;
}

template <typename T, typename Y>
inline bool
operator<(const persistent_ptr<T> &lhs, const persistent_ptr<Y> &rhs) noexcept
{
    if (lhs.raw().pool_uuid_lo == rhs.raw().pool_uuid_lo)
        return lhs.raw().off < rhs.raw().off;
    else
        return lhs.raw().pool_uuid_lo < rhs.raw().pool_uuid_lo;
}

template <typename T, typename Y>
inline bool
operator<=(const persistent_ptr<T> &lhs, const persistent_ptr<Y> &rhs) noexcept
{
    return !(rhs < lhs);
}

template <typename T, typename Y>
inline bool
operator>(const persistent_ptr<T> &lhs, const persistent_ptr<Y> &rhs) noexcept
{
    return (rhs < lhs);
}

template <typename T, typename Y>
inline bool
operator>=(const persistent_ptr<T> &lhs, const persistent_ptr<Y> &rhs) noexcept
{
    return !(lhs < rhs);
}

/* nullptr comparisons */

template <typename T>
inline bool
operator<(const persistent_ptr<T> &lhs, std::nullptr_t) noexcept
{
    return std::less<typename persistent_ptr<T>::element_type *>()(
        lhs.get(), nullptr);
}

template <typename T>
inline bool
operator<(std::nullptr_t, const persistent_ptr<T> &rhs) noexcept
{
    return std::less<typename persistent_ptr<T>::element_type *>()(
        nullptr, rhs.get());
}

template <typename T>
inline bool
operator<=(const persistent_ptr<T> &lhs, std::nullptr_t) noexcept
{
    return !(nullptr < lhs);
}

template <typename T>
inline bool
operator<=(std::nullptr_t, const persistent_ptr<T> &rhs) noexcept
{
    return !(rhs < nullptr);
}

template <typename T>
inline bool
operator>(const persistent_ptr<T> &lhs, std::nullptr_t) noexcept
{
    return nullptr < lhs;
}

template <typename T>
inline bool
operator>(std::nullptr_t, const persistent_ptr<T> &rhs) noexcept
{
    return rhs < nullptr;
}

template <typename T>
inline bool
operator>=(const persistent_ptr<T> &lhs, std::nullptr_t) noexcept
{
    return !(lhs < nullptr);
}

template <typename T>
inline bool
operator>=(std::nullptr_t, const persistent_ptr<T> &rhs) noexcept
{
    return !(nullptr < rhs);
}

template <typename T>
inline persistent_ptr<T>
operator+(const persistent_ptr<T> &lhs, std::ptrdiff_t s)
{
    PMEMoid noid;
    noid.pool_uuid_lo = lhs.raw().pool_uuid_lo;
    noid.off = lhs.raw().off + (s * sizeof(T));
    return persistent_ptr<T>(noid);
}

template <typename T>
inline persistent_ptr<T>
operator-(const persistent_ptr<T> &lhs, std::ptrdiff_t s)
{
    PMEMoid noid;
    noid.pool_uuid_lo = lhs.raw().pool_uuid_lo;
    noid.off = lhs.raw().off - (s * sizeof(T));
    return persistent_ptr<T>(noid);
}

template <typename T>
inline ptrdiff_t
operator-(const persistent_ptr<T> &lhs, const persistent_ptr<T> &rhs)
{
    assert(lhs.raw().pool_uuid_lo == rhs.raw().pool_uuid_lo);
    ptrdiff_t d = lhs.raw().off - rhs.raw().off;

    return d / sizeof(T);
}

template <typename T>
std::ostream &
operator<<(std::ostream &os, const persistent_ptr<T> &pptr)
{
    PMEMoid raw_oid = pptr.raw();
    os << std::hex << "0x" << raw_oid.pool_uuid_lo << ", 0x" << raw_oid.off
       << std::dec;
    return os;
}

} /* namespace obj */

} /* namespace nvml */

#endif /* PMEMOBJ_PERSISTENT_PTR_HPP */