Inheritance diagram for Slic3r::UndoRedo::ObjectHistory< T >:

Collaboration diagram for Slic3r::UndoRedo::ObjectHistory< T >:

Public Member Functions
	~ObjectHistory () override
bool	empty () override
size_t	release_before_timestamp (size_t timestamp) override
size_t	release_after_timestamp (size_t timestamp) override
size_t	release_between_timestamps (size_t timestamp_start, size_t timestamp_end) override
virtual bool	is_mutable () const =0
virtual bool	is_immutable () const =0
virtual bool	is_optional () const
virtual const void *	immutable_object_ptr () const
virtual size_t	release_optional ()=0
virtual void	restore_optional ()=0
virtual size_t	memsize () const =0
virtual bool	valid ()=0

Protected Attributes
std::vector< T >	m_history

Detailed Description

template<typename T>
class Slic3r::UndoRedo::ObjectHistory< T >

Constructor & Destructor Documentation

◆ ~ObjectHistory()

template<typename T>

Slic3r::UndoRedo::ObjectHistory< T >::~ObjectHistory ( )

inlineoverride

144{}

Member Function Documentation

◆ empty()

template<typename T>

bool Slic3r::UndoRedo::ObjectHistory< T >::empty ( )

inlineoverridevirtual

Implements Slic3r::UndoRedo::ObjectHistoryBase.

147{ return m_history.empty(); }

Slic3r::UndoRedo::ObjectHistory::m_history

std::vector< T > m_history

Definition UndoRedo.cpp:228

References m_history.

◆ immutable_object_ptr()

virtual const void * Slic3r::UndoRedo::ObjectHistoryBase::immutable_object_ptr ( ) const

inlinevirtualinherited

Reimplemented in Slic3r::UndoRedo::ImmutableObjectHistory< T >.

108{ return nullptr; }

◆ is_immutable()

virtual bool Slic3r::UndoRedo::ObjectHistoryBase::is_immutable ( ) const

pure virtualinherited

Implemented in Slic3r::UndoRedo::ImmutableObjectHistory< T >, and Slic3r::UndoRedo::MutableObjectHistory< T >.

◆ is_mutable()

virtual bool Slic3r::UndoRedo::ObjectHistoryBase::is_mutable ( ) const

pure virtualinherited

Implemented in Slic3r::UndoRedo::ImmutableObjectHistory< T >, and Slic3r::UndoRedo::MutableObjectHistory< T >.

◆ is_optional()

virtual bool Slic3r::UndoRedo::ObjectHistoryBase::is_optional ( ) const

inlinevirtualinherited

Reimplemented in Slic3r::UndoRedo::ImmutableObjectHistory< T >.

106{ return false; }

◆ memsize()

virtual size_t Slic3r::UndoRedo::ObjectHistoryBase::memsize ( ) const

pure virtualinherited

Implemented in Slic3r::UndoRedo::ImmutableObjectHistory< T >, and Slic3r::UndoRedo::MutableObjectHistory< T >.

◆ release_after_timestamp()

template<typename T>

size_t Slic3r::UndoRedo::ObjectHistory< T >::release_after_timestamp ( size_t timestamp )

inlineoverridevirtual

Implements Slic3r::UndoRedo::ObjectHistoryBase.

                                                            {
    size_t mem_released = 0;
    if (! m_history.empty()) {
      assert(this->valid());
      // it points to an interval which either starts with timestamp, or follows the timestamp.
      auto it = std::lower_bound(m_history.begin(), m_history.end(), T(timestamp, timestamp));
      if (it != m_history.begin()) {
        auto it_prev = it;
        -- it_prev;
        assert(it_prev->begin() < timestamp);
        // Trim the last interval with timestamp.
        it_prev->trim_end(timestamp);
      }
      for (auto it2 = it; it2 != m_history.end(); ++ it2)
        mem_released += it2->memsize();
      m_history.erase(it, m_history.end());
      assert(this->valid());
    }
    return mem_released;
  }

References m_history, and Slic3r::UndoRedo::ObjectHistoryBase::valid().

Here is the call graph for this function:

◆ release_before_timestamp()

template<typename T>

size_t Slic3r::UndoRedo::ObjectHistory< T >::release_before_timestamp ( size_t timestamp )

inlineoverridevirtual

Implements Slic3r::UndoRedo::ObjectHistoryBase.

                                                             {
    size_t mem_released = 0;
    if (! m_history.empty()) {
      assert(this->valid());
      // it points to an interval which either starts with timestamp, or follows the timestamp.
      auto it = std::lower_bound(m_history.begin(), m_history.end(), T(timestamp, timestamp));
      // Find the first iterator with begin() < timestamp.
      if (it == m_history.end())
        -- it;
      while (it != m_history.begin() && it->begin() >= timestamp)
        -- it;
      if (it->begin() < timestamp && it->end() > timestamp) {
        it->trim_begin(timestamp);
        if (it != m_history.begin())
          -- it;
      }
      if (it->end() <= timestamp) {
        auto it_end = ++ it;
        for (it = m_history.begin(); it != it_end; ++ it)
          mem_released += it->memsize();
        m_history.erase(m_history.begin(), it_end);
      }
      assert(this->valid());
    }
    return mem_released;
  }

References m_history, and Slic3r::UndoRedo::ObjectHistoryBase::valid().

Here is the call graph for this function:

◆ release_between_timestamps()

template<typename T>

size_t Slic3r::UndoRedo::ObjectHistory< T >::release_between_timestamps	(	size_t	timestamp_start,
		size_t	timestamp_end )

inlineoverridevirtual

Implements Slic3r::UndoRedo::ObjectHistoryBase.

                                                                                           {
    size_t mem_released = 0;
    if (! m_history.empty()) {
      assert(this->valid());
      // Find the span of m_history intervals that are fully in (timestamp_start, timestamp_end>, thus they will be never
      // deserialized for any snapshot in <timestamp_start, timestamp_end).
      auto it_lo = std::upper_bound(m_history.begin(), m_history.end(), timestamp_start, [](size_t l, const auto &r) { return l < r.begin(); });
      auto it_hi = std::upper_bound(it_lo, m_history.end(), timestamp_end, [](size_t l, const auto &r) { return l < r.end(); });
      if (it_lo != it_hi) {
        // There are some intervals that start inside (timestamp_start, timestamp_end), that could be released.
        assert(it_lo->begin() > timestamp_start && it_lo->end() <= timestamp_end);
        assert(it_hi == m_history.end() || (it_hi->begin() > it_lo->begin() && it_hi->end() > timestamp_end));
        if (it_lo != m_history.begin() && it_hi != m_history.end()) {
          // One may consider merging the two intervals.
          //FIXME merge them.
        }
        for (auto it = it_lo; it != it_hi; ++ it)
          mem_released += it->memsize();
        m_history.erase(it_lo, it_hi);
      }
      assert(this->valid());
    }
    return mem_released;
  }