|
| | shared_blob ()=delete |
| |
| | shared_blob (shared_blob &&)=default |
| |
| | shared_blob (const shared_blob &s)=default |
| |
| shared_blob & | operator= (const shared_blob &s)=default |
| |
| shared_blob & | operator= (shared_blob &&)=default |
| |
| template<typename InputIterator > |
| | shared_blob (InputIterator f, InputIterator l, const allocator_type &a) |
| |
| | shared_blob (const allocator_type &a) |
| |
| | 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 |
| |
For bugs in boost interprocess we moved our blob data to shared_string this wrapper allows us to continue that while also having a type-level distinction for serialization and to/from variant
Definition at line 96 of file types.hpp.