chainbase::undo_index< T, Allocator, Indices > Class Template Reference

#include <undo_index.hpp>

Classes
struct	delta
struct	node
struct	old_node
class	removed_nodes_tracker
class	session
struct	undo_state

Public Types
using	id_type = std::decay_t<decltype(std::declval<T>().id)>
using	value_type = T
using	allocator_type = Allocator
using	indices_type = std::tuple<set_impl<node, Indices>...>
using	index0_set_type = std::tuple_element_t<0, indices_type>
using	alloc_traits = typename std::allocator_traits<Allocator>::template rebind_traits<node>
using	index0_type = boost::mp11::mp_first<boost::mp11::mp_list<Indices...>>
using	id_pointer = id_type*
using	pointer = value_type*
using	const_iterator = typename index0_set_type::const_iterator

Public Member Functions
	undo_index ()=default
	undo_index (const Allocator &a)
	~undo_index ()
void	validate () const
template<typename Constructor >
const value_type &	emplace (Constructor &&c)
template<typename Modifier >
void	modify (const value_type &obj, Modifier &&m)
auto	track_removed ()
void	remove (const value_type &obj) noexcept
template<typename CompatibleKey >
const value_type *	find (CompatibleKey &&key) const
template<typename CompatibleKey >
const value_type &	get (CompatibleKey &&key) const
void	remove_object (int64_t id)
int64_t	revision () const
session	start_undo_session (bool enabled)
void	set_revision (uint64_t revision)
std::pair< int64_t, int64_t >	undo_stack_revision_range () const
void	commit (int64_t revision) noexcept
const undo_index &	indices () const
template<typename Tag >
const auto &	get () const
template<int N>
const auto &	get () const
std::size_t	size () const
bool	empty () const
template<typename Tag , typename Iter >
auto	project (Iter iter) const
template<int N, typename Iter >
auto	project (Iter iter) const
bool	has_undo_session () const
delta	last_undo_session () const
auto	begin () const
auto	end () const
void	undo_all ()
void	undo () noexcept
void	squash () noexcept
void	squash_fast () noexcept
void	squash_and_compress () noexcept
void	compress_last_undo_session () noexcept

Static Public Attributes
static constexpr int	erased_flag = 2

Detailed Description

template<typename T, typename Allocator, typename... Indices>
class chainbase::undo_index< T, Allocator, Indices >

Definition at line 235 of file undo_index.hpp.

Member Typedef Documentation

alloc_traits

template<typename T , typename Allocator , typename... Indices>

using chainbase::undo_index< T, Allocator, Indices >::alloc_traits = typename std::allocator_traits<Allocator>::template rebind_traits<node>

Definition at line 269 of file undo_index.hpp.

allocator_type

template<typename T , typename Allocator , typename... Indices>

using chainbase::undo_index< T, Allocator, Indices >::allocator_type = Allocator

Definition at line 239 of file undo_index.hpp.

const_iterator

template<typename T , typename Allocator , typename... Indices>

using chainbase::undo_index< T, Allocator, Indices >::const_iterator = typename index0_set_type::const_iterator

Definition at line 285 of file undo_index.hpp.

id_pointer

template<typename T , typename Allocator , typename... Indices>

using chainbase::undo_index< T, Allocator, Indices >::id_pointer = id_type*

Definition at line 283 of file undo_index.hpp.

id_type

template<typename T , typename Allocator , typename... Indices>

using chainbase::undo_index< T, Allocator, Indices >::id_type = std::decay_t<decltype(std::declval<T>().id)>

Definition at line 237 of file undo_index.hpp.

index0_set_type

template<typename T , typename Allocator , typename... Indices>

using chainbase::undo_index< T, Allocator, Indices >::index0_set_type = std::tuple_element_t<0, indices_type>

Definition at line 268 of file undo_index.hpp.

index0_type

template<typename T , typename Allocator , typename... Indices>

using chainbase::undo_index< T, Allocator, Indices >::index0_type = boost::mp11::mp_first<boost::mp11::mp_list<Indices...>>

Definition at line 273 of file undo_index.hpp.

indices_type

template<typename T , typename Allocator , typename... Indices>

using chainbase::undo_index< T, Allocator, Indices >::indices_type = std::tuple<set_impl<node, Indices>...>

Definition at line 266 of file undo_index.hpp.

pointer

template<typename T , typename Allocator , typename... Indices>

using chainbase::undo_index< T, Allocator, Indices >::pointer = value_type*

Definition at line 284 of file undo_index.hpp.

value_type

template<typename T , typename Allocator , typename... Indices>

using chainbase::undo_index< T, Allocator, Indices >::value_type = T

Definition at line 238 of file undo_index.hpp.

Constructor & Destructor Documentation

undo_index() [1/2]

template<typename T , typename Allocator , typename... Indices>

chainbase::undo_index< T, Allocator, Indices >::undo_index ( )

default

undo_index() [2/2]

template<typename T , typename Allocator , typename... Indices>

chainbase::undo_index< T, Allocator, Indices >::undo_index ( const Allocator & a )

inlineexplicit

Definition at line 244 of file undo_index.hpp.

: _undo_stack{a}, _allocator{a}, _old_values_allocator{a} {}

~undo_index()

template<typename T , typename Allocator , typename... Indices>

chainbase::undo_index< T, Allocator, Indices >::~undo_index ( )

inline

Definition at line 245 of file undo_index.hpp.

                    {
         dispose_undo();
         clear_impl<1>();
         std::get<0>(_indices).clear_and_dispose([&](pointer p){ dispose_node(*p); });
      }

Member Function Documentation

begin()

template<typename T , typename Allocator , typename... Indices>

auto chainbase::undo_index< T, Allocator, Indices >::begin ( ) const

inline

Definition at line 600 of file undo_index.hpp.

{ return get<0>().begin(); }

Here is the call graph for this function:

Here is the caller graph for this function:

commit()

template<typename T , typename Allocator , typename... Indices>

void chainbase::undo_index< T, Allocator, Indices >::commit ( int64_t revision )

inlinenoexcept

Discards all undo history prior to revision

Definition at line 540 of file undo_index.hpp.

                                               {
         revision = std::min(revision, _revision);
         if (revision == _revision) {
            dispose_undo();
            _undo_stack.clear();
         } else if( static_cast<uint64_t>(_revision - revision) < _undo_stack.size() ) {
            auto iter = _undo_stack.begin() + (_undo_stack.size() - (_revision - revision));
            dispose(get_old_values_end(*iter), get_removed_values_end(*iter));
            _undo_stack.erase(_undo_stack.begin(), iter);
         }
      }

Here is the call graph for this function:

Here is the caller graph for this function:

compress_last_undo_session()

template<typename T , typename Allocator , typename... Indices>

void chainbase::undo_index< T, Allocator, Indices >::compress_last_undo_session ( )

inlinenoexcept

Definition at line 676 of file undo_index.hpp.

                                                 {
         compress_impl(_undo_stack.back());
      }

Here is the caller graph for this function:

emplace()

template<typename T , typename Allocator , typename... Indices>

template<typename Constructor >

const value_type & chainbase::undo_index< T, Allocator, Indices >::emplace ( Constructor && c )

inline

Definition at line 341 of file undo_index.hpp.

                                                   {
         auto p = alloc_traits::allocate(_allocator, 1);
         auto guard0 = scope_exit{[&]{ alloc_traits::deallocate(_allocator, p, 1); }};
         auto new_id = _next_id;
         auto constructor = [&]( value_type& v ) {
            v.id = new_id;
            c( v );
         };
         alloc_traits::construct(_allocator, &*p, constructor, propagate_allocator(_allocator));
         auto guard1 = scope_exit{[&]{ alloc_traits::destroy(_allocator, &*p); }};
         if(!insert_impl<1>(p->_item))
            BOOST_THROW_EXCEPTION( std::logic_error{ "could not insert object, most likely a uniqueness constraint was violated" } );
         std::get<0>(_indices).push_back(p->_item); // cannot fail and we know that it will definitely insert at the end.
         on_create(p->_item);
         ++_next_id;
         guard1.cancel();
         guard0.cancel();
         return p->_item;
      }

Here is the call graph for this function:

Here is the caller graph for this function:

empty()

template<typename T , typename Allocator , typename... Indices>

bool chainbase::undo_index< T, Allocator, Indices >::empty ( ) const

inline

Definition at line 563 of file undo_index.hpp.

                         {
         return std::get<0>(_indices).empty();
      }

end()

template<typename T , typename Allocator , typename... Indices>

auto chainbase::undo_index< T, Allocator, Indices >::end ( ) const

inline

Definition at line 601 of file undo_index.hpp.

{ return get<0>().end(); }

Here is the call graph for this function:

Here is the caller graph for this function:

find()

template<typename T , typename Allocator , typename... Indices>

template<typename CompatibleKey >

const value_type * chainbase::undo_index< T, Allocator, Indices >::find ( CompatibleKey && key ) const

inline

Definition at line 451 of file undo_index.hpp.

                                                         {
         const auto& index = std::get<0>(_indices);
         auto iter = index.find(static_cast<CompatibleKey&&>(key));
         if (iter != index.end()) {
            return &*iter;
         } else {
            return nullptr;
         }
      }

Here is the caller graph for this function:

get() [1/3]

template<typename T , typename Allocator , typename... Indices>

template<typename Tag >

const auto & chainbase::undo_index< T, Allocator, Indices >::get ( ) const

inline

Definition at line 554 of file undo_index.hpp.

{ return std::get<find_tag<Tag, Indices...>::value>(_indices); }

Here is the caller graph for this function:

get() [2/3]

template<typename T , typename Allocator , typename... Indices>

template<int N>

const auto & chainbase::undo_index< T, Allocator, Indices >::get ( ) const

inline

Definition at line 557 of file undo_index.hpp.

{ return std::get<N>(_indices); }

get() [3/3]

template<typename T , typename Allocator , typename... Indices>

template<typename CompatibleKey >

const value_type & chainbase::undo_index< T, Allocator, Indices >::get ( CompatibleKey && key ) const

inline

Definition at line 462 of file undo_index.hpp.

                                                        {
         auto ptr = find( static_cast<CompatibleKey&&>(key) );
         if( !ptr ) {
            std::stringstream ss;
            ss << "key not found (" << boost::core::demangle( typeid( key ).name() ) << "): " << key;
            BOOST_THROW_EXCEPTION( std::out_of_range( ss.str().c_str() ) );
         }
         return *ptr;
      }

Here is the call graph for this function:

Here is the caller graph for this function:

has_undo_session()

template<typename T , typename Allocator , typename... Indices>

bool chainbase::undo_index< T, Allocator, Indices >::has_undo_session ( ) const

inline

Definition at line 579 of file undo_index.hpp.

{ return !_undo_stack.empty(); }

Here is the caller graph for this function:

indices()

template<typename T , typename Allocator , typename... Indices>

const undo_index & chainbase::undo_index< T, Allocator, Indices >::indices ( ) const

inline

Definition at line 552 of file undo_index.hpp.

{ return *this; }

last_undo_session()

template<typename T , typename Allocator , typename... Indices>

delta chainbase::undo_index< T, Allocator, Indices >::last_undo_session ( ) const

inline

Definition at line 587 of file undo_index.hpp.

                                      {
        if(_undo_stack.empty())
           return { { get<0>().end(), get<0>().end() },
                    { _old_values.end(), _old_values.end() },
                    { _removed_values.end(), _removed_values.end() } };
         // Warning: This is safe ONLY as long as nothing exposes the undo stack to client code.
         // Compressing the undo stack does not change the logical state of the undo_index.
         const_cast<undo_index*>(this)->compress_last_undo_session();
         return { { get<0>().lower_bound(_undo_stack.back().old_next_id), get<0>().end() },
                  { _old_values.begin(), get_old_values_end(_undo_stack.back()) },
                  { _removed_values.begin(), get_removed_values_end(_undo_stack.back()) } };
      }

Here is the call graph for this function:

modify()

template<typename T , typename Allocator , typename... Indices>

template<typename Modifier >

void chainbase::undo_index< T, Allocator, Indices >::modify ( const value_type & obj, Modifier && m )

inline

Definition at line 365 of file undo_index.hpp.

                                                        {
         value_type* backup = on_modify(obj);
         value_type& node_ref = const_cast<value_type&>(obj);
         bool success = false;
         {
            auto guard0 = scope_exit{[&]{
               if(!post_modify<true, 1>(node_ref)) { // The object id cannot be modified
                  if(backup) {
                     node_ref = std::move(*backup);
                     bool success = post_modify<true, 1>(node_ref);
                     (void)success;
                     assert(success);
                     assert(backup == &_old_values.front());
                     _old_values.pop_front_and_dispose([this](pointer p){ dispose_old(*p); });
                  } else {
                     remove(obj);
                  }
               } else {
                  success = true;
               }
            }};
            auto old_id = obj.id;
            m(node_ref);
            (void)old_id;
            assert(obj.id == old_id);
         }
         if(!success)
            BOOST_THROW_EXCEPTION( std::logic_error{ "could not modify object, most likely a uniqueness constraint was violated" } );
      }

Here is the call graph for this function:

Here is the caller graph for this function:

project() [1/2]

template<typename T , typename Allocator , typename... Indices>

template<typename Tag , typename Iter >

auto chainbase::undo_index< T, Allocator, Indices >::project ( Iter iter ) const

inline

Definition at line 568 of file undo_index.hpp.

                                    {
         return project<find_tag<Tag, Indices...>::value>(iter);
      }

Here is the call graph for this function:

Here is the caller graph for this function:

project() [2/2]

template<typename T , typename Allocator , typename... Indices>

template<int N, typename Iter >

auto chainbase::undo_index< T, Allocator, Indices >::project ( Iter iter ) const

inline

Definition at line 573 of file undo_index.hpp.

                                    {
         if(iter == get<boost::mp11::mp_find<boost::mp11::mp_list<typename set_impl<node, Indices>::const_iterator...>, Iter>::value>().end())
            return get<N>().end();
         return get<N>().iterator_to(*iter);
      }

Here is the call graph for this function:

remove()

template<typename T , typename Allocator , typename... Indices>

void chainbase::undo_index< T, Allocator, Indices >::remove ( const value_type & obj )

inlinenoexcept

Definition at line 430 of file undo_index.hpp.

                                                    {
         auto& node_ref = const_cast<value_type&>(obj);
         erase_impl(node_ref);
         if(on_remove(node_ref)) {
            dispose_node(node_ref);
         }
      }

Here is the caller graph for this function:

remove_object()

template<typename T , typename Allocator , typename... Indices>

void chainbase::undo_index< T, Allocator, Indices >::remove_object ( int64_t id )

inline

Definition at line 472 of file undo_index.hpp.

                                       {
         const value_type* val = find( typename value_type::id_type(id) );
         if( !val ) BOOST_THROW_EXCEPTION( std::out_of_range( boost::lexical_cast<std::string>(id) ) );
         remove( *val );
      }

Here is the call graph for this function:

revision()

template<typename T , typename Allocator , typename... Indices>

int64_t chainbase::undo_index< T, Allocator, Indices >::revision ( ) const

inline

Definition at line 514 of file undo_index.hpp.

{ return _revision; }

Here is the caller graph for this function:

set_revision()

template<typename T , typename Allocator , typename... Indices>

void chainbase::undo_index< T, Allocator, Indices >::set_revision ( uint64_t revision )

inline

Definition at line 520 of file undo_index.hpp.

                                             {
         if( _undo_stack.size() != 0 )
            BOOST_THROW_EXCEPTION( std::logic_error("cannot set revision while there is an existing undo stack") );
 
         if( revision > std::numeric_limits<int64_t>::max() )
            BOOST_THROW_EXCEPTION( std::logic_error("revision to set is too high") );
 
         if( static_cast<int64_t>(revision) < _revision )
            BOOST_THROW_EXCEPTION( std::logic_error("revision cannot decrease") );
 
         _revision = static_cast<int64_t>(revision);
      }

Here is the call graph for this function:

size()

template<typename T , typename Allocator , typename... Indices>

std::size_t chainbase::undo_index< T, Allocator, Indices >::size ( ) const

inline

Definition at line 559 of file undo_index.hpp.

                             {
         return std::get<0>(_indices).size();
      }

squash()

template<typename T , typename Allocator , typename... Indices>

void chainbase::undo_index< T, Allocator, Indices >::squash ( )

inlinenoexcept

Definition at line 655 of file undo_index.hpp.

                             {
         squash_and_compress();
      }

Here is the call graph for this function:

Here is the caller graph for this function:

squash_and_compress()

template<typename T , typename Allocator , typename... Indices>

void chainbase::undo_index< T, Allocator, Indices >::squash_and_compress ( )

inlinenoexcept

Definition at line 669 of file undo_index.hpp.

                                          {
         if(_undo_stack.size() >= 2) {
            compress_impl(_undo_stack[_undo_stack.size() - 2]);
         }
         squash_fast();
      }

Here is the call graph for this function:

Here is the caller graph for this function:

squash_fast()

template<typename T , typename Allocator , typename... Indices>

void chainbase::undo_index< T, Allocator, Indices >::squash_fast ( )

inlinenoexcept

Definition at line 659 of file undo_index.hpp.

                                  {
         if (_undo_stack.empty()) {
            return;
         } else if (_undo_stack.size() == 1) {
            dispose_undo();
         }
         _undo_stack.pop_back();
         --_revision;
      }

Here is the caller graph for this function:

start_undo_session()

template<typename T , typename Allocator , typename... Indices>

session chainbase::undo_index< T, Allocator, Indices >::start_undo_session ( bool enabled )

inline

Definition at line 516 of file undo_index.hpp.

                                                 {
         return session{*this, enabled};
      }

Here is the caller graph for this function:

track_removed()

template<typename T , typename Allocator , typename... Indices>

auto chainbase::undo_index< T, Allocator, Indices >::track_removed ( )

inline

Definition at line 426 of file undo_index.hpp.

                           {
         return removed_nodes_tracker(*this);
      }

Here is the caller graph for this function:

undo()

template<typename T , typename Allocator , typename... Indices>

void chainbase::undo_index< T, Allocator, Indices >::undo ( )

inlinenoexcept

Definition at line 610 of file undo_index.hpp.

                           {
         if (_undo_stack.empty()) return;
         undo_state& undo_info = _undo_stack.back();
         // erase all new_ids
         auto& by_id = std::get<0>(_indices);
         auto new_ids_iter = by_id.lower_bound(undo_info.old_next_id);
         by_id.erase_and_dispose(new_ids_iter, by_id.end(), [this](pointer p){
            erase_impl<1>(*p);
            dispose_node(*p);
         });
         // replace old_values
         _old_values.erase_after_and_dispose(_old_values.before_begin(), get_old_values_end(undo_info), [this, &undo_info](pointer p) {
            auto restored_mtime = to_old_node(*p)._mtime;
            // Skip restoring values that overwrite an earlier modify in the same session.
            // Duplicate modifies can only happen because of squash.
            if(restored_mtime < undo_info.ctime) {
               auto iter = &to_old_node(*p)._current->_item;
               *iter = std::move(*p);
               auto& node_mtime = to_node(*iter)._mtime;
               node_mtime = restored_mtime;
               if (get_removed_field(*iter) != erased_flag) {
                  // Non-unique items are transient and are guaranteed to be fixed
                  // by the time we finish processing old_values.
                  post_modify<false, 1>(*iter);
               } else {
                  // The item was removed.  It will be inserted when we process removed_values
               }
            }
            dispose_old(*p);
         });
         // insert all removed_values
         _removed_values.erase_after_and_dispose(_removed_values.before_begin(), get_removed_values_end(undo_info), [this, &undo_info](pointer p) {
            if (p->id < undo_info.old_next_id) {
               get_removed_field(*p) = 0; // Will be overwritten by tree algorithms, because we're reusing the color.
               insert_impl(*p);
            } else {
               dispose_node(*p);
            }
         });
         _next_id = undo_info.old_next_id;
         _undo_stack.pop_back();
         --_revision;
      }

Here is the caller graph for this function:

undo_all()

template<typename T , typename Allocator , typename... Indices>

void chainbase::undo_index< T, Allocator, Indices >::undo_all ( )

inline

Definition at line 603 of file undo_index.hpp.

                      {
         while(!_undo_stack.empty()) {
            undo();
         }
      }

Here is the call graph for this function:

undo_stack_revision_range()

template<typename T , typename Allocator , typename... Indices>

std::pair< int64_t, int64_t > chainbase::undo_index< T, Allocator, Indices >::undo_stack_revision_range ( ) const

inline

Definition at line 533 of file undo_index.hpp.

                                                                  {
         return { _revision - _undo_stack.size(), _revision };
      }

validate()

template<typename T , typename Allocator , typename... Indices>

void chainbase::undo_index< T, Allocator, Indices >::validate ( ) const

inline

Definition at line 251 of file undo_index.hpp.

                           {
         if( sizeof(node) != _size_of_value_type || sizeof(*this) != _size_of_this )
            BOOST_THROW_EXCEPTION( std::runtime_error("content of memory does not match data expected by executable") );
      }

Member Data Documentation

erased_flag

template<typename T , typename Allocator , typename... Indices>

int chainbase::undo_index< T, Allocator, Indices >::erased_flag = 2

staticconstexpr

Definition at line 264 of file undo_index.hpp.

---

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

• libraries/chainbase/include/chainbase/undo_index.hpp