pmem::obj::experimental::basic_dram_inline_string< CharT, Traits > Class Template Reference

This class serves similar purpose to pmem::obj::string, but keeps the data within the same allocation as inline_string itself. More...

#include <libpmemobj++/experimental/inline_string.hpp>

Inherits pmem::obj::experimental::basic_inline_string_base< CharT, Traits >.

Detailed Description

template<typename CharT, typename Traits = std::char_traits<CharT>>
class pmem::obj::experimental::basic_dram_inline_string< CharT, Traits >

This class serves similar purpose to pmem::obj::string, but keeps the data within the same allocation as inline_string itself.

Unlike other containers, it can be used on pmem and dram. Modifiers (like assign()) can only be called if inline string is kept on pmem).

The data is always kept right after the inline_string structure. It means that creating an object of inline_string must be done as follows:

1. Allocate memory of sizeof(inline_string) + size of the characters string + sizeof('\0')
2. Use emplace new() to create inline_string

Example:

struct Object {
    Object(int x, const char *s) : x(x), s(s)
    {
    }

    int x;

    /* Using inline_string instead of pmem::obj::string reduces number of
     * allocations and dereferences which cost much more than on DRAM.
     */
    pmem::obj::experimental::inline_string s;
};

struct root {
    pmem::obj::persistent_ptr<Object> o;
};

void
create_and_print_object(pmem::obj::pool<root> pop)
{
    auto r = pop.root();

    pmem::obj::transaction::run(pop, [&] {
        /* String was already allocated in a previous app run. */
        if (r->o)
            return;

        auto value = "example";

        /* There must be space for the Object itself and "example"
         * string. */
        auto req_capacity =
            sizeof(Object) + strlen(value) + sizeof('\0');

        pmem::obj::allocator<void> a;
        r->o = static_cast<pmem::obj::persistent_ptr<Object>>(
            a.allocate(req_capacity));
        new (r->o.get()) Object(1, value);
    });

    std::cout << r->o->s.data() << std::endl;
}

void
assign_and_print_object(pmem::obj::pool<root> pop)
{
    auto r = pop.root();

    auto new_value = "some new, longer value";

    if (r->o->s.capacity() >= strlen(new_value)) {
        /* If there is enough capacity, we can assign the new value. */
        r->o->s.assign(new_value);
    } else {
        /* Otherwise we have to reallocate the whole object. */
        pmem::obj::transaction::run(pop, [&] {
            pmem::obj::allocator<void> a;
            auto ptr =
                static_cast<pmem::obj::persistent_ptr<Object>>(
                    a.allocate(sizeof(Object) +
                           strlen(new_value) + 1));
            new (ptr.get()) Object(r->o->x, new_value);

            pmem::obj::delete_persistent<Object>(r->o);
            r->o = ptr;
        });
    }

    std::cout << r->o->s.data() << std::endl;
}

---

The documentation for this class was generated from the following file:

• libpmemobj++/experimental/inline_string.hpp