basic_string.hpp

Go to the documentation of this file.

/*
 * Copyright 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_BASIC_STRING_HPP
#define LIBPMEMOBJ_CPP_BASIC_STRING_HPP
 
#include <algorithm>
#include <limits>
#include <string>
 
#include <libpmemobj++/detail/common.hpp>
#include <libpmemobj++/detail/iterator_traits.hpp>
#include <libpmemobj++/detail/life.hpp>
#include <libpmemobj++/experimental/array.hpp>
#include <libpmemobj++/experimental/contiguous_iterator.hpp>
#include <libpmemobj++/experimental/slice.hpp>
#include <libpmemobj++/experimental/vector.hpp>
#include <libpmemobj++/persistent_ptr.hpp>
#include <libpmemobj++/pext.hpp>
#include <libpmemobj++/transaction.hpp>
 
namespace pmem
{
 
namespace obj
{
 
namespace experimental
{
 
template <typename CharT, typename Traits = std::char_traits<CharT>>
class basic_string {
public:
    /* Member types */
    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 iterator = basic_contiguous_iterator<CharT>;
    using const_iterator = const_pointer;
    using reverse_iterator = std::reverse_iterator<iterator>;
    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
    /* Number of characters which can be stored using sso */
    static constexpr size_type sso_capacity = 64 - sizeof('\0');
 
    basic_string()
    {
        check_pmem_tx();
 
        initialize(0U, value_type('\0'));
    }
 
    basic_string(size_type count, CharT ch)
    {
        check_pmem_tx();
 
        initialize(count, ch);
    }
 
    basic_string(const basic_string &other, size_type pos,
             size_type count = npos)
    {
        check_pmem_tx();
 
        if (pos > other.size())
            throw std::out_of_range("Index out of range.");
 
        if (count == npos || pos + count > other.size())
            count = other.size() - pos;
 
        auto first = static_cast<difference_type>(pos);
        auto last = first + static_cast<difference_type>(count);
 
        initialize(other.cbegin() + first, other.cbegin() + last);
    }
 
    basic_string(const CharT *s, size_type count)
    {
        check_pmem_tx();
 
        initialize(s, s + count);
    }
 
    basic_string(const CharT *s)
    {
        check_pmem_tx();
 
        auto length = traits_type::length(s);
 
        initialize(s, s + length);
    }
 
    template <
        typename InputIt,
        typename Enable = typename std::enable_if<
            pmem::detail::is_input_iterator<InputIt>::value>::type>
    basic_string(InputIt first, InputIt last)
    {
        assert(std::distance(first, last) >= 0);
 
        check_pmem_tx();
 
        initialize(first, last);
    }
 
    basic_string(const basic_string &other)
    {
        check_pmem_tx();
 
        initialize(other.cbegin(), other.cend());
    }
 
    basic_string(basic_string &&other)
    {
        check_pmem_tx();
 
        initialize(std::move(other));
 
        if (other.is_sso_used())
            other.initialize(0U, value_type('\0'));
    }
 
    basic_string(std::initializer_list<CharT> ilist)
    {
        check_pmem_tx();
 
        initialize(ilist.begin(), ilist.end());
    }
 
    ~basic_string()
    {
        if (!is_sso_used())
            detail::destroy<non_sso_type>(data_large);
    }
 
    basic_string &
    operator=(const basic_string &other)
    {
        return assign(other);
    }
 
    basic_string &
    operator=(basic_string &&other)
    {
        return assign(std::move(other));
    }
 
    basic_string &
    operator=(const CharT *s)
    {
        return assign(s);
    }
 
    basic_string &
    operator=(CharT ch)
    {
        return assign(1, ch);
    }
 
    basic_string &
    operator=(std::initializer_list<CharT> ilist)
    {
        return assign(ilist);
    }
 
    basic_string &
    assign(size_type count, CharT ch)
    {
        auto pop = get_pool();
 
        transaction::run(pop, [&] { replace(count, ch); });
 
        return *this;
    }
 
    basic_string &
    assign(const basic_string &other)
    {
        if (&other == this)
            return *this;
 
        auto pop = get_pool();
 
        transaction::run(
            pop, [&] { replace(other.cbegin(), other.cend()); });
 
        return *this;
    }
 
    basic_string &
    assign(const basic_string &other, size_type pos, size_type count = npos)
    {
        if (pos > other.size())
            throw std::out_of_range("Index out of range.");
 
        if (count == npos || pos + count > other.size())
            count = other.size() - pos;
 
        auto pop = get_pool();
        auto first = static_cast<difference_type>(pos);
        auto last = first + static_cast<difference_type>(count);
 
        transaction::run(pop, [&] {
            replace(other.cbegin() + first, other.cbegin() + last);
        });
 
        return *this;
    }
 
    basic_string &
    assign(const CharT *s, size_type count)
    {
        auto pop = get_pool();
 
        transaction::run(pop, [&] { replace(s, s + count); });
 
        return *this;
    }
 
    basic_string &
    assign(const CharT *s)
    {
        auto pop = get_pool();
 
        auto length = traits_type::length(s);
 
        transaction::run(pop, [&] { replace(s, s + length); });
 
        return *this;
    }
 
    template <typename InputIt,
          typename Enable = typename pmem::detail::is_input_iterator<
              InputIt>::type>
    basic_string &
    assign(InputIt first, InputIt last)
    {
        auto pop = get_pool();
 
        transaction::run(pop, [&] { replace(first, last); });
 
        return *this;
    }
 
    basic_string &
    assign(basic_string &&other)
    {
        if (&other == this)
            return *this;
 
        auto pop = get_pool();
 
        transaction::run(pop, [&] {
            replace(std::move(other));
 
            if (other.is_sso_used())
                other.initialize(0U, value_type('\0'));
        });
 
        return *this;
    }
 
    basic_string &
    assign(std::initializer_list<CharT> ilist)
    {
        return assign(ilist.begin(), ilist.end());
    }
 
    iterator
    begin()
    {
        return is_sso_used() ? iterator(&*data_sso.begin())
                     : iterator(&*data_large.begin());
    }
 
    const_iterator
    begin() const noexcept
    {
        return cbegin();
    }
 
    const_iterator
    cbegin() const noexcept
    {
        return is_sso_used() ? const_iterator(&*data_sso.cbegin())
                     : const_iterator(&*data_large.cbegin());
    }
 
    iterator
    end()
    {
        return begin() + static_cast<difference_type>(size());
    }
 
    const_iterator
    end() const noexcept
    {
        return cbegin() + static_cast<difference_type>(size());
    }
 
    const_iterator
    cend() const noexcept
    {
        return cbegin() + static_cast<difference_type>(size());
    }
 
    reverse_iterator
    rbegin()
    {
        return reverse_iterator(end());
    }
 
    const_reverse_iterator
    rbegin() const noexcept
    {
        return crbegin();
    }
 
    const_reverse_iterator
    crbegin() const noexcept
    {
        return const_reverse_iterator(cend());
    }
 
    reverse_iterator
    rend()
    {
        return reverse_iterator(begin());
    }
 
    const_reverse_iterator
    rend() const noexcept
    {
        return crend();
    }
 
    const_reverse_iterator
    crend() const noexcept
    {
        return const_reverse_iterator(cbegin());
    }
 
    reference
    at(size_type n)
    {
        if (n >= size())
            throw std::out_of_range("string::at");
 
        return is_sso_used() ? data_sso[n] : data_large[n];
    }
 
    const_reference
    at(size_type n) const
    {
        return const_at(n);
    }
 
    const_reference
    const_at(size_type n) const
    {
        if (n >= size())
            throw std::out_of_range("string::const_at");
 
        return is_sso_used()
            ? static_cast<const sso_type &>(data_sso)[n]
            : static_cast<const non_sso_type &>(data_large)[n];
    }
 
    reference operator[](size_type n)
    {
        return is_sso_used() ? data_sso[n] : data_large[n];
    }
 
    const_reference operator[](size_type n) const
    {
        return is_sso_used() ? data_sso[n] : data_large[n];
    }
 
    CharT &
    front()
    {
        return (*this)[0];
    }
 
    const CharT &
    front() const
    {
        return cfront();
    }
 
    const CharT &
    cfront() const
    {
        return static_cast<const basic_string &>(*this)[0];
    }
 
    CharT &
    back()
    {
        return (*this)[size() - 1];
    }
 
    const CharT &
    back() const
    {
        return cback();
    }
 
    const CharT &
    cback() const
    {
        return static_cast<const basic_string &>(*this)[size() - 1];
    }
 
    size_type
    size() const noexcept
    {
        if (is_sso_used())
            return _size;
        else if (data_large.size() == 0)
            return 0;
        else
            return data_large.size() - sizeof('\0');
    }
 
    CharT *
    data()
    {
        return is_sso_used()
            ? data_sso.range(0, size() + sizeof('\0')).begin()
            : data_large.data();
    }
 
    int
    compare(size_type pos, size_type count1, const CharT *s,
        size_type count2) const
    {
        if (pos > size())
            throw std::out_of_range("Index out of range.");
 
        if (count1 > size() - pos)
            count1 = size() - pos;
 
        auto ret = traits_type::compare(
            cdata() + pos, s, std::min<size_type>(count1, count2));
 
        if (ret != 0)
            return ret;
 
        if (count1 < count2)
            return -1;
        else if (count1 == count2)
            return 0;
        else
            return 1;
    }
 
    int
    compare(const basic_string &other) const
    {
        return compare(0, size(), other.cdata(), other.size());
    }
 
    int
    compare(size_type pos, size_type count, const basic_string &other) const
    {
        return compare(pos, count, other.cdata(), other.size());
    }
 
    int
    compare(size_type pos1, size_type count1, const basic_string &other,
        size_type pos2, size_type count2 = npos) const
    {
        if (pos2 > other.size())
            throw std::out_of_range("Index out of range.");
 
        if (count2 > other.size() - pos2)
            count2 = other.size() - pos2;
 
        return compare(pos1, count1, other.cdata() + pos2, count2);
    }
 
    int
    compare(const CharT *s) const
    {
        return compare(0, size(), s, traits_type::length(s));
    }
 
    int
    compare(size_type pos, size_type count, const CharT *s) const
    {
        return compare(pos, count, s, traits_type::length(s));
    }
 
    const CharT *
    cdata() const noexcept
    {
        return is_sso_used() ? data_sso.cdata() : data_large.cdata();
    }
 
    const CharT *
    data() const noexcept
    {
        return cdata();
    }
 
    const CharT *
    c_str() const noexcept
    {
        return cdata();
    }
 
    size_type
    length() const noexcept
    {
        return size();
    }
 
    size_type
    max_size() const noexcept
    {
        return PMEMOBJ_MAX_ALLOC_SIZE / sizeof(CharT) - 1;
    }
 
    size_type
    capacity() const noexcept
    {
        return is_sso_used() ? sso_capacity
                     : data_large.capacity() - sizeof('\0');
    }
 
    bool
    empty() const noexcept
    {
        return size() == 0;
    }
 
    /* Special value. The exact meaning depends on the context. */
    static const size_type npos = static_cast<size_type>(-1);
 
private:
    using sso_type = array<value_type, sso_capacity + sizeof('\0')>;
    using non_sso_type = vector<value_type>;
 
    union {
        sso_type data_sso;
 
        non_sso_type data_large;
    };
 
    /* Holds size if sso is used, std::numeric_limits<size_type>::max()
     * otherwise */
    p<size_type> _size;
 
    bool
    is_sso_used() const
    {
        assert(_size <= sso_capacity ||
               _size == std::numeric_limits<size_type>::max());
 
        return _size <= sso_capacity;
    }
 
    void
    destroy_data()
    {
        assert(pmemobj_tx_stage() == TX_STAGE_WORK);
 
        /*
         * XXX: this can be optimized - only snapshot length() elements.
         */
#if LIBPMEMOBJ_CPP_VG_MEMCHECK_ENABLED
        VALGRIND_MAKE_MEM_DEFINED(&data_sso, sizeof(data_sso));
#endif
 
        if (is_sso_used()) {
            data_sso.data();
            /* data_sso constructor does not have to be called */
        } else {
            data_large.free_data();
            detail::destroy<decltype(data_large)>(data_large);
        }
    }
 
    template <
        typename InputIt,
        typename Enable = typename std::enable_if<
            pmem::detail::is_input_iterator<InputIt>::value>::type>
    size_type
    get_size(InputIt first, InputIt last) const
    {
        return static_cast<size_type>(std::distance(first, last));
    }
 
    size_type
    get_size(size_type count, value_type ch) const
    {
        return count;
    }
 
    size_type
    get_size(const basic_string &other) const
    {
        return other.size();
    }
 
    template <typename... Args>
    pointer
    replace(Args &&... args)
    {
        assert(pmemobj_tx_stage() == TX_STAGE_WORK);
 
        auto new_size = get_size(std::forward<Args>(args)...);
 
        /* If data_large is used and there is enough capacity */
        if (!is_sso_used() && new_size <= capacity())
            return assign_large_data(std::forward<Args>(args)...);
 
        destroy_data();
 
        return initialize(std::forward<Args>(args)...);
    }
 
    template <typename... Args>
    pointer
    initialize(Args &&... args)
    {
        assert(pmemobj_tx_stage() == TX_STAGE_WORK);
 
        auto new_size = get_size(std::forward<Args>(args)...);
 
        if (new_size <= sso_capacity)
            _size = new_size;
        else
            _size = std::numeric_limits<size_type>::max();
 
        if (is_sso_used()) {
            /*
             * array is aggregate type so it's not required to call
             * a constructor.
             */
            return assign_sso_data(std::forward<Args>(args)...);
        } else {
            detail::create<decltype(data_large)>(&data_large);
            return assign_large_data(std::forward<Args>(args)...);
        }
    }
 
    template <
        typename InputIt,
        typename Enable = typename std::enable_if<
            pmem::detail::is_input_iterator<InputIt>::value>::type>
    pointer
    assign_sso_data(InputIt first, InputIt last)
    {
        auto size = static_cast<size_type>(std::distance(first, last));
 
        assert(pmemobj_tx_stage() == TX_STAGE_WORK);
        assert(size <= sso_capacity);
 
        auto dest = data_sso.range(0, size + sizeof('\0')).begin();
        std::copy(first, last, dest);
 
        dest[size] = value_type('\0');
 
        return dest;
    }
 
    pointer
    assign_sso_data(size_type count, value_type ch)
    {
        assert(pmemobj_tx_stage() == TX_STAGE_WORK);
        assert(count <= sso_capacity);
 
        auto dest = data_sso.range(0, count + sizeof('\0')).begin();
        traits_type::assign(dest, count, ch);
 
        dest[count] = value_type('\0');
 
        return dest;
    }
 
    pointer
    assign_sso_data(basic_string &&other)
    {
        assert(pmemobj_tx_stage() == TX_STAGE_WORK);
 
        return assign_sso_data(other.cbegin(), other.cend());
    }
 
    template <
        typename InputIt,
        typename Enable = typename std::enable_if<
            pmem::detail::is_input_iterator<InputIt>::value>::type>
    pointer
    assign_large_data(InputIt first, InputIt last)
    {
        assert(pmemobj_tx_stage() == TX_STAGE_WORK);
 
        auto size = static_cast<size_type>(std::distance(first, last));
 
        data_large.reserve(size + sizeof('\0'));
        data_large.assign(first, last);
        data_large.push_back(value_type('\0'));
 
        return data_large.data();
    }
 
    pointer
    assign_large_data(size_type count, value_type ch)
    {
        assert(pmemobj_tx_stage() == TX_STAGE_WORK);
 
        data_large.reserve(count + sizeof('\0'));
        data_large.assign(count, ch);
        data_large.push_back(value_type('\0'));
 
        return data_large.data();
    }
 
    pointer
    assign_large_data(basic_string &&other)
    {
        assert(pmemobj_tx_stage() == TX_STAGE_WORK);
 
        if (other.is_sso_used())
            return assign_large_data(other.cbegin(), other.cend());
 
        data_large = std::move(other.data_large);
 
        return data_large.data();
    }
 
    pool_base
    get_pool() const
    {
        auto pop = pmemobj_pool_by_ptr(this);
        assert(pop != nullptr);
 
        return pool_base(pop);
    }
 
    void
    check_pmem() const
    {
        if (pmemobj_pool_by_ptr(this) == nullptr)
            throw pool_error("Object is not on pmem.");
    }
 
    void
    check_tx_stage_work() const
    {
        if (pmemobj_tx_stage() != TX_STAGE_WORK)
            throw transaction_error(
                "Call made out of transaction scope.");
    }
 
    void
    check_pmem_tx() const
    {
        check_pmem();
        check_tx_stage_work();
    }
};
 
template <class CharT, class Traits>
bool
operator==(const basic_string<CharT, Traits> &lhs,
       const basic_string<CharT, Traits> &rhs)
{
    return lhs.compare(rhs) == 0;
}
 
template <class CharT, class Traits>
bool
operator!=(const basic_string<CharT, Traits> &lhs,
       const basic_string<CharT, Traits> &rhs)
{
    return lhs.compare(rhs) != 0;
}
 
template <class CharT, class Traits>
bool
operator<(const basic_string<CharT, Traits> &lhs,
      const basic_string<CharT, Traits> &rhs)
{
    return lhs.compare(rhs) < 0;
}
 
template <class CharT, class Traits>
bool
operator<=(const basic_string<CharT, Traits> &lhs,
       const basic_string<CharT, Traits> &rhs)
{
    return lhs.compare(rhs) <= 0;
}
 
template <class CharT, class Traits>
bool
operator>(const basic_string<CharT, Traits> &lhs,
      const basic_string<CharT, Traits> &rhs)
{
    return lhs.compare(rhs) > 0;
}
 
template <class CharT, class Traits>
bool
operator>=(const basic_string<CharT, Traits> &lhs,
       const basic_string<CharT, Traits> &rhs)
{
    return lhs.compare(rhs) >= 0;
}
 
template <class CharT, class Traits>
bool
operator==(const CharT *lhs, const basic_string<CharT, Traits> &rhs)
{
    return rhs.compare(lhs) == 0;
}
 
template <class CharT, class Traits>
bool
operator!=(const CharT *lhs, const basic_string<CharT, Traits> &rhs)
{
    return rhs.compare(lhs) != 0;
}
 
template <class CharT, class Traits>
bool
operator<(const CharT *lhs, const basic_string<CharT, Traits> &rhs)
{
    return rhs.compare(lhs) > 0;
}
 
template <class CharT, class Traits>
bool
operator<=(const CharT *lhs, const basic_string<CharT, Traits> &rhs)
{
    return rhs.compare(lhs) >= 0;
}
 
template <class CharT, class Traits>
bool
operator>(const CharT *lhs, const basic_string<CharT, Traits> &rhs)
{
    return rhs.compare(lhs) < 0;
}
 
template <class CharT, class Traits>
bool
operator>=(const CharT *lhs, const basic_string<CharT, Traits> &rhs)
{
    return rhs.compare(lhs) <= 0;
}
 
template <class CharT, class Traits>
bool
operator==(const basic_string<CharT, Traits> &lhs, const CharT *rhs)
{
    return lhs.compare(rhs) == 0;
}
 
template <class CharT, class Traits>
bool
operator!=(const basic_string<CharT, Traits> &lhs, const CharT *rhs)
{
    return lhs.compare(rhs) != 0;
}
 
template <class CharT, class Traits>
bool
operator<(const basic_string<CharT, Traits> &lhs, const CharT *rhs)
{
    return lhs.compare(rhs) < 0;
}
 
template <class CharT, class Traits>
bool
operator<=(const basic_string<CharT, Traits> &lhs, const CharT *rhs)
{
    return lhs.compare(rhs) <= 0;
}
 
template <class CharT, class Traits>
bool
operator>(const basic_string<CharT, Traits> &lhs, const CharT *rhs)
{
    return lhs.compare(rhs) > 0;
}
 
template <class CharT, class Traits>
bool
operator>=(const basic_string<CharT, Traits> &lhs, const CharT *rhs)
{
    return lhs.compare(rhs) >= 0;
}
 
} /* namespace experimental */
 
} /* namespace obj */
 
} /* namespace pmem */
 
#endif /* LIBPMEMOBJ_CPP_BASIC_STRING_HPP */