chainbase::shared_cow_string Class Reference

#include <shared_cow_string.hpp>

Inheritance diagram for chainbase::shared_cow_string:

Public Types
using	allocator_type = bip::allocator<char, pinnable_mapped_file::segment_manager>
using	iterator = const char*
using	const_iterator = const char*

Public Member Functions
	shared_cow_string (const allocator_type &alloc)
template<typename Iter >
	shared_cow_string (Iter begin, Iter end, const allocator_type &alloc)
	shared_cow_string (const char *ptr, std::size_t size, const allocator_type &alloc)
	shared_cow_string (std::size_t size, boost::container::default_init_t, const allocator_type &alloc)
	shared_cow_string (const shared_cow_string &other)
	shared_cow_string (shared_cow_string &&other)
shared_cow_string &	operator= (const shared_cow_string &other)
shared_cow_string &	operator= (shared_cow_string &&other)
	~shared_cow_string ()
void	resize (std::size_t new_size, boost::container::default_init_t)
template<typename F >
void	resize_and_fill (std::size_t new_size, F &&f)
void	assign (const char *ptr, std::size_t size)
void	assign (const unsigned char *ptr, std::size_t size)
const char *	data () const
std::size_t	size () const
const_iterator	begin () const
const_iterator	end () const
int	compare (std::size_t start, std::size_t count, const char *other, std::size_t other_size) const
bool	operator== (const shared_cow_string &rhs) const
bool	operator!= (const shared_cow_string &rhs) const
const allocator_type &	get_allocator () const

Detailed Description

Definition at line 18 of file shared_cow_string.hpp.

Member Typedef Documentation

allocator_type

using chainbase::shared_cow_string::allocator_type = bip::allocator<char, pinnable_mapped_file::segment_manager>

Definition at line 25 of file shared_cow_string.hpp.

const_iterator

using chainbase::shared_cow_string::const_iterator = const char*

Definition at line 27 of file shared_cow_string.hpp.

iterator

using chainbase::shared_cow_string::iterator = const char*

Definition at line 26 of file shared_cow_string.hpp.

Constructor & Destructor Documentation

shared_cow_string() [1/6]

chainbase::shared_cow_string::shared_cow_string ( const allocator_type & alloc )

inlineexplicit

Definition at line 28 of file shared_cow_string.hpp.

: _data(nullptr), _alloc(alloc) {}

shared_cow_string() [2/6]

template<typename Iter >

chainbase::shared_cow_string::shared_cow_string ( Iter begin, Iter end, const allocator_type & alloc )

inlineexplicit

Definition at line 30 of file shared_cow_string.hpp.

                                                                                    : shared_cow_string(alloc) {
         std::size_t size = std::distance(begin, end);
         impl* new_data = (impl*)&*_alloc.allocate(sizeof(impl) + size + 1);
         new_data->reference_count = 1;
         new_data->size = size;
         std::copy(begin, end, new_data->data);
         new_data->data[size] = '\0';
         _data = new_data;
      }

Here is the call graph for this function:

shared_cow_string() [3/6]

chainbase::shared_cow_string::shared_cow_string ( const char * ptr, std::size_t size, const allocator_type & alloc )

inlineexplicit

Definition at line 39 of file shared_cow_string.hpp.

                                                                                               : shared_cow_string(alloc) {
         impl* new_data = (impl*)&*_alloc.allocate(sizeof(impl) + size + 1);
         new_data->reference_count = 1;
         new_data->size = size;
         std::memcpy(new_data->data, ptr, size);
         new_data->data[size] = '\0';
         _data = new_data;
      }

Here is the call graph for this function:

shared_cow_string() [4/6]

chainbase::shared_cow_string::shared_cow_string ( std::size_t size, boost::container::default_init_t , const allocator_type & alloc )

inlineexplicit

Definition at line 47 of file shared_cow_string.hpp.

                                                                                                            : shared_cow_string(alloc) {
         impl* new_data = (impl*)&*_alloc.allocate(sizeof(impl) + size + 1);
         new_data->reference_count = 1;
         new_data->size = size;
         new_data->data[size] = '\0';
         _data = new_data;
      }

Here is the call graph for this function:

shared_cow_string() [5/6]

chainbase::shared_cow_string::shared_cow_string ( const shared_cow_string & other )

inline

Definition at line 54 of file shared_cow_string.hpp.

                                                        : _data(other._data), _alloc(other._alloc) {
         if(_data != nullptr) {
            ++_data->reference_count;
         }
      }

shared_cow_string() [6/6]

chainbase::shared_cow_string::shared_cow_string ( shared_cow_string && other )

inline

Definition at line 59 of file shared_cow_string.hpp.

                                                   : _data(other._data), _alloc(other._alloc) {
         other._data = nullptr;
      }

~shared_cow_string()

chainbase::shared_cow_string::~shared_cow_string ( )

inline

Definition at line 74 of file shared_cow_string.hpp.

                           {
         dec_refcount();
      }

Member Function Documentation

assign() [1/2]

void chainbase::shared_cow_string::assign ( const char * ptr, std::size_t size )

inline

Definition at line 90 of file shared_cow_string.hpp.

                                                   {
         impl* new_data = (impl*)&*_alloc.allocate(sizeof(impl) + size + 1);
         new_data->reference_count = 1;
         new_data->size = size;
         if(size)
            std::memcpy(new_data->data, ptr, size);
         new_data->data[size] = '\0';
         dec_refcount();
         _data = new_data;
      }

Here is the call graph for this function:

Here is the caller graph for this function:

assign() [2/2]

void chainbase::shared_cow_string::assign ( const unsigned char * ptr, std::size_t size )

inline

Definition at line 100 of file shared_cow_string.hpp.

                                                            {
         assign((char*)ptr, size);
      }

Here is the call graph for this function:

begin()

const_iterator chainbase::shared_cow_string::begin ( ) const

inline

Definition at line 111 of file shared_cow_string.hpp.

{ return data(); }

Here is the call graph for this function:

compare()

int chainbase::shared_cow_string::compare ( std::size_t start, std::size_t count, const char * other, std::size_t other_size ) const

inline

Definition at line 116 of file shared_cow_string.hpp.

                                                                                                   {
         std::size_t sz = size();
         if(start > sz) BOOST_THROW_EXCEPTION(std::out_of_range{"shared_cow_string::compare"});
         count = std::min(count, sz - start);
         std::size_t cmp_len = std::min(count, other_size);
         const char* start_ptr = data() + start;
         int result = std::char_traits<char>::compare(start_ptr, other, cmp_len);
         if (result != 0) return result;
         else if (count < other_size) return -1;
         else if(count > other_size) return 1;
         else return 0;
      }

Here is the call graph for this function:

data()

const char * chainbase::shared_cow_string::data ( ) const

inline

Definition at line 103 of file shared_cow_string.hpp.

                                {
         if (_data) return _data->data;
         else return nullptr;
      }

Here is the caller graph for this function:

end()

const_iterator chainbase::shared_cow_string::end ( ) const

inline

Definition at line 112 of file shared_cow_string.hpp.

                                 {
         if (_data) return _data->data + _data->size;
         else return nullptr;
      }

get_allocator()

const allocator_type & chainbase::shared_cow_string::get_allocator ( ) const

inline

Definition at line 132 of file shared_cow_string.hpp.

{ return _alloc; }

Here is the caller graph for this function:

operator!=()

bool chainbase::shared_cow_string::operator!= ( const shared_cow_string & rhs ) const

inline

Definition at line 131 of file shared_cow_string.hpp.

{ return !(*this == rhs); }

operator=() [1/2]

shared_cow_string & chainbase::shared_cow_string::operator= ( const shared_cow_string & other )

inline

Definition at line 62 of file shared_cow_string.hpp.

                                                                   {
         *this = shared_cow_string{other};
         return *this;
      }

operator=() [2/2]

shared_cow_string & chainbase::shared_cow_string::operator= ( shared_cow_string && other )

inline

Definition at line 66 of file shared_cow_string.hpp.

                                                              {
         if (this != &other) {
            dec_refcount();
            _data = other._data;
            other._data = nullptr;
         }
         return *this;
      }

operator==()

bool chainbase::shared_cow_string::operator== ( const shared_cow_string & rhs ) const

inline

Definition at line 128 of file shared_cow_string.hpp.

                                                          {
        return size() == rhs.size() && std::memcmp(data(), rhs.data(), size()) == 0;
      }

Here is the call graph for this function:

resize()

void chainbase::shared_cow_string::resize ( std::size_t new_size, boost::container::default_init_t  )

inline

Definition at line 77 of file shared_cow_string.hpp.

                                                                    {
         impl* new_data = (impl*)&*_alloc.allocate(sizeof(impl) + new_size + 1);
         new_data->reference_count = 1;
         new_data->size = new_size;
         new_data->data[new_size] = '\0';
         dec_refcount();
         _data = new_data;
      }

Here is the caller graph for this function:

resize_and_fill()

template<typename F >

void chainbase::shared_cow_string::resize_and_fill ( std::size_t new_size, F && f )

inline

Definition at line 86 of file shared_cow_string.hpp.

                                                      {
         resize(new_size, boost::container::default_init);
         static_cast<F&&>(f)(_data->data, new_size);
      }

Here is the call graph for this function:

Here is the caller graph for this function:

size()

std::size_t chainbase::shared_cow_string::size ( ) const

inline

Definition at line 107 of file shared_cow_string.hpp.

                             {
         if (_data) return _data->size;
         else return 0;
      }

Here is the caller graph for this function:

---

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

• libraries/chainbase/include/chainbase/shared_cow_string.hpp