inline_string.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-3-Clause
/* Copyright 2020-2021, Intel Corporation */
 
#ifndef LIBPMEMOBJ_CPP_INLINE_STRING_HPP
#define LIBPMEMOBJ_CPP_INLINE_STRING_HPP
 
#include <libpmemobj++/make_persistent.hpp>
#include <libpmemobj++/persistent_ptr.hpp>
#include <libpmemobj++/slice.hpp>
#include <libpmemobj++/string_view.hpp>
#include <libpmemobj++/transaction.hpp>
 
#include <string>
 
namespace pmem
{
 
namespace obj
{
 
namespace experimental
{
 
template <typename CharT, typename Traits = std::char_traits<CharT>>
class basic_inline_string_base {
public:
    using traits_type = Traits;
    using value_type = CharT;
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;
    using reference = value_type &;
    using const_reference = const value_type &;
    using pointer = value_type *;
    using const_pointer = const value_type *;
 
    basic_inline_string_base(basic_string_view<CharT, Traits> v);
    basic_inline_string_base(size_type capacity);
    basic_inline_string_base(const basic_inline_string_base &rhs);
 
    basic_inline_string_base &
    operator=(const basic_inline_string_base &rhs);
 
    basic_inline_string_base &
    operator=(basic_string_view<CharT, Traits> rhs);
 
    basic_inline_string_base(basic_inline_string_base<CharT> &&) = delete;
 
    basic_inline_string_base &
    operator=(basic_inline_string_base &&) = delete;
    operator basic_string_view<CharT, Traits>() const;
 
    size_type size() const noexcept;
    size_type capacity() const noexcept;
 
    pointer data();
    const_pointer data() const noexcept;
    const_pointer cdata() const noexcept;
 
    int compare(basic_string_view<CharT, Traits> rhs) const noexcept;
 
    reference operator[](size_type p);
    const_reference operator[](size_type p) const noexcept;
 
    reference at(size_type p);
    const_reference at(size_type p) const;
 
    slice<pointer> range(size_type p, size_type count);
 
    basic_inline_string_base &assign(basic_string_view<CharT, Traits> rhs);
 
protected:
    pointer snapshotted_data(size_t p, size_t n);
 
    obj::p<uint64_t> size_;
    obj::p<uint64_t> capacity_;
};
 
template <typename CharT, typename Traits = std::char_traits<CharT>>
class basic_dram_inline_string
    : public basic_inline_string_base<CharT, Traits> {
public:
    using traits_type = Traits;
    using value_type = CharT;
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;
    using reference = value_type &;
    using const_reference = const value_type &;
    using pointer = value_type *;
    using const_pointer = const value_type *;
    using basic_inline_string_base<CharT, Traits>::operator=;
 
    basic_dram_inline_string(basic_string_view<CharT, Traits> v)
        : basic_inline_string_base<CharT, Traits>(v)
    {
    }
 
    basic_dram_inline_string(size_type capacity)
        : basic_inline_string_base<CharT, Traits>(capacity)
    {
    }
    basic_dram_inline_string(const basic_dram_inline_string &rhs)
        : basic_inline_string_base<CharT, Traits>(rhs)
    {
    }
 
    basic_dram_inline_string &
    operator=(const basic_dram_inline_string &rhs)
    {
        return static_cast<basic_dram_inline_string &>(this->operator=(
            static_cast<const basic_inline_string_base<
                CharT, Traits> &>(rhs)));
    }
};
 
template <typename CharT, typename Traits = std::char_traits<CharT>>
class basic_inline_string : public basic_inline_string_base<CharT, Traits> {
public:
    using traits_type = Traits;
    using value_type = CharT;
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;
    using reference = value_type &;
    using const_reference = const value_type &;
    using pointer = value_type *;
    using const_pointer = const value_type *;
    using basic_inline_string_base<CharT, Traits>::operator=;
 
    basic_inline_string(basic_string_view<CharT, Traits> v)
        : basic_inline_string_base<CharT, Traits>(check_forward(v))
    {
    }
 
    basic_inline_string(size_type capacity)
        : basic_inline_string_base<CharT, Traits>(check_forward(capacity))
    {
    }
 
    basic_inline_string(const basic_inline_string &rhs)
        : basic_inline_string_base<CharT, Traits>(check_forward(rhs))
    {
    }
 
    basic_inline_string &
    operator=(const basic_inline_string &rhs)
    {
        return static_cast<basic_inline_string &>(this->operator=(
            static_cast<const basic_inline_string_base<
                CharT, Traits> &>(rhs)));
    }
 
private:
    template <typename T>
    T &&
    check_forward(T &&t)
    {
        if (nullptr == pmemobj_pool_by_ptr(this))
            throw pmem::pool_error("Invalid pool handle.");
        return std::forward<T>(t);
    }
};
 
using dram_inline_string = basic_dram_inline_string<char>;
using dram_inline_wstring = basic_dram_inline_string<wchar_t>;
using dram_inline_u16string = basic_dram_inline_string<char16_t>;
using dram_inline_u32string = basic_dram_inline_string<char32_t>;
 
using inline_string = basic_inline_string<char>;
using inline_wstring = basic_inline_string<wchar_t>;
using inline_u16string = basic_inline_string<char16_t>;
using inline_u32string = basic_inline_string<char32_t>;
 
template <typename CharT, typename Traits>
basic_inline_string_base<CharT, Traits>::basic_inline_string_base(
    basic_string_view<CharT, Traits> v)
    : size_(v.size()), capacity_(v.size())
{
    std::copy(v.data(), v.data() + static_cast<ptrdiff_t>(size_), data());
 
    data()[static_cast<ptrdiff_t>(size_)] = '\0';
}
 
template <typename CharT, typename Traits>
basic_inline_string_base<CharT, Traits>::basic_inline_string_base(
    size_type capacity)
    : size_(0), capacity_(capacity)
{
    data()[static_cast<ptrdiff_t>(size_)] = '\0';
}
 
template <typename CharT, typename Traits>
basic_inline_string_base<CharT, Traits>::basic_inline_string_base(
    const basic_inline_string_base &rhs)
    : size_(rhs.size()), capacity_(rhs.capacity())
{
    std::copy(rhs.data(), rhs.data() + static_cast<ptrdiff_t>(size_),
          data());
 
    data()[static_cast<ptrdiff_t>(size_)] = '\0';
}
 
template <typename CharT, typename Traits>
basic_inline_string_base<CharT, Traits> &
basic_inline_string_base<CharT, Traits>::operator=(
    const basic_inline_string_base &rhs)
{
    if (this == &rhs)
        return *this;
 
    return assign(rhs);
}
 
template <typename CharT, typename Traits>
basic_inline_string_base<CharT, Traits> &
basic_inline_string_base<CharT, Traits>::operator=(
    basic_string_view<CharT, Traits> rhs)
{
    return assign(rhs);
}
 
template <typename CharT, typename Traits>
basic_inline_string_base<CharT, Traits>::operator basic_string_view<
    CharT, Traits>() const
{
    return {data(), size()};
}
 
template <typename CharT, typename Traits>
typename basic_inline_string_base<CharT, Traits>::size_type
basic_inline_string_base<CharT, Traits>::size() const noexcept
{
    return size_;
}
 
template <typename CharT, typename Traits>
typename basic_inline_string_base<CharT, Traits>::size_type
basic_inline_string_base<CharT, Traits>::capacity() const noexcept
{
    return capacity_;
}
 
template <typename CharT, typename Traits>
typename basic_inline_string_base<CharT, Traits>::pointer
basic_inline_string_base<CharT, Traits>::data()
{
    return snapshotted_data(0, size_);
}
 
template <typename CharT, typename Traits>
typename basic_inline_string_base<CharT, Traits>::const_pointer
basic_inline_string_base<CharT, Traits>::data() const noexcept
{
    return cdata();
}
 
template <typename CharT, typename Traits>
typename basic_inline_string_base<CharT, Traits>::const_pointer
basic_inline_string_base<CharT, Traits>::cdata() const noexcept
{
    return reinterpret_cast<const CharT *>(this + 1);
}
 
template <typename CharT, typename Traits>
int
basic_inline_string_base<CharT, Traits>::compare(
    basic_string_view<CharT, Traits> rhs) const noexcept
{
    return basic_string_view<CharT, Traits>(data(), size()).compare(rhs);
}
 
template <typename CharT, typename Traits>
typename basic_inline_string_base<CharT, Traits>::reference
    basic_inline_string_base<CharT, Traits>::operator[](size_type p)
{
    return snapshotted_data(p, 1)[0];
}
 
template <typename CharT, typename Traits>
typename basic_inline_string_base<CharT, Traits>::const_reference
    basic_inline_string_base<CharT, Traits>::operator[](size_type p) const
    noexcept
{
    return cdata()[p];
}
 
template <typename CharT, typename Traits>
typename basic_inline_string_base<CharT, Traits>::reference
basic_inline_string_base<CharT, Traits>::at(size_type p)
{
    if (p >= size())
        throw std::out_of_range("basic_inline_string_base::at");
 
    return snapshotted_data(p, 1)[0];
}
 
template <typename CharT, typename Traits>
typename basic_inline_string_base<CharT, Traits>::const_reference
basic_inline_string_base<CharT, Traits>::at(size_type p) const
{
    if (p >= size())
        throw std::out_of_range("basic_inline_string_base::at");
 
    return cdata()[p];
}
 
template <typename CharT, typename Traits>
slice<typename basic_inline_string_base<CharT, Traits>::pointer>
basic_inline_string_base<CharT, Traits>::range(size_type start, size_type n)
{
    if (start + n > size())
        throw std::out_of_range("basic_inline_string_base::range");
 
    auto data = snapshotted_data(start, n);
 
    return {data, data + n};
}
 
template <typename CharT, typename Traits>
typename basic_inline_string_base<CharT, Traits>::pointer
basic_inline_string_base<CharT, Traits>::snapshotted_data(size_t p, size_t n)
{
    assert(p + n <= size());
 
    detail::conditional_add_to_tx(reinterpret_cast<CharT *>(this + 1) + p,
                      n, POBJ_XADD_ASSUME_INITIALIZED);
 
    return reinterpret_cast<CharT *>(this + 1) + p;
}
 
template <typename CharT, typename Traits>
basic_inline_string_base<CharT, Traits> &
basic_inline_string_base<CharT, Traits>::assign(
    basic_string_view<CharT, Traits> rhs)
{
    auto cpop = pmemobj_pool_by_ptr(this);
    if (nullptr == cpop)
        throw pmem::pool_error("Invalid pool handle.");
 
    auto pop = pool_base(cpop);
 
    if (rhs.size() > capacity())
        throw std::out_of_range("inline_string capacity exceeded.");
 
    auto initialized_mem =
        (std::min)(rhs.size(), size()) + 1 /* sizeof('\0') */;
 
    obj::flat_transaction::run(pop, [&] {
        detail::conditional_add_to_tx(data(), initialized_mem);
 
        if (rhs.size() > size())
            detail::conditional_add_to_tx(
                data() + initialized_mem,
                rhs.size() - initialized_mem + 1,
                POBJ_XADD_NO_SNAPSHOT);
 
        std::copy(rhs.data(),
              rhs.data() + static_cast<ptrdiff_t>(rhs.size()),
              data());
        size_ = rhs.size();
 
        data()[static_cast<ptrdiff_t>(size_)] = '\0';
    });
 
    return *this;
}
 
template <typename T>
struct total_sizeof {
    template <typename... Args>
    static size_t
    value(const Args &... args)
    {
        return sizeof(T);
    }
};
 
template <typename CharT, typename Traits>
struct total_sizeof<basic_inline_string<CharT, Traits>> {
    static size_t
    value(const basic_string_view<CharT, Traits> &s)
    {
        return sizeof(basic_inline_string_base<CharT, Traits>) +
            (s.size() + 1 /* '\0' */) * sizeof(CharT);
    }
};
 
template <typename CharT, typename Traits>
struct total_sizeof<basic_dram_inline_string<CharT, Traits>> {
    static size_t
    value(const basic_string_view<CharT, Traits> &s)
    {
        return sizeof(basic_dram_inline_string<CharT, Traits>) +
            (s.size() + 1 /* '\0' */) * sizeof(CharT);
    }
};
} /* namespace experimental */
} /* namespace obj */
 
namespace detail
{
/* Check if type is pmem::obj::basic_inline_string or
 * pmem::obj::basic_dram_inline_string */
template <typename>
struct is_inline_string : std::false_type {
};
 
template <typename CharT, typename Traits>
struct is_inline_string<obj::experimental::basic_inline_string<CharT, Traits>>
    : std::true_type {
};
 
template <typename CharT, typename Traits>
struct is_inline_string<
    obj::experimental::basic_dram_inline_string<CharT, Traits>>
    : std::true_type {
};
 
} /* namespace detail */
 
} /* namespace pmem */
 
#endif /* LIBPMEMOBJ_CPP_INLINE_STRING_HPP */