Slic3r::UndoRedo::MutableObjectHistory< T > Class Template Reference

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

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

Public Member Functions
	~MutableObjectHistory () override
bool	is_mutable () const override
bool	is_immutable () const override
size_t	memsize () const override
bool	try_save_timestamp (size_t active_snapshot_time, size_t current_time, uint64_t timestamp)
void	save (size_t active_snapshot_time, size_t current_time, const std::string &data)
std::string	load (size_t timestamp) const
size_t	release_optional () override
void	restore_optional () override
bool	valid () 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_optional () const
virtual const void *	immutable_object_ptr () const

Protected Attributes
std::vector< MutableHistoryInterval >	m_history

Detailed Description

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

Constructor & Destructor Documentation

~MutableObjectHistory()

template<typename T>

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

inlineoverride

{}

Member Function Documentation

empty()

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

inlineoverridevirtualinherited

Implements Slic3r::UndoRedo::ObjectHistoryBase.

{ return m_history.empty(); }

immutable_object_ptr()

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

inlinevirtualinherited

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

{ return nullptr; }

is_immutable()

template<typename T>

bool Slic3r::UndoRedo::MutableObjectHistory< T >::is_immutable ( ) const

inlineoverridevirtual

Implements Slic3r::UndoRedo::ObjectHistoryBase.

{ return false; }

is_mutable()

template<typename T>

bool Slic3r::UndoRedo::MutableObjectHistory< T >::is_mutable ( ) const

inlineoverridevirtual

Implements Slic3r::UndoRedo::ObjectHistoryBase.

{ return true; }

is_optional()

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

inlinevirtualinherited

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

{ return false; }

load()

template<typename T>

std::string Slic3r::UndoRedo::MutableObjectHistory< T >::load ( size_t timestamp ) const

inline

                                         {
    assert(! m_history.empty());
    auto it = std::lower_bound(m_history.begin(), m_history.end(), MutableHistoryInterval(timestamp, timestamp));
    if (it == m_history.end() || it->begin() > timestamp) {
      //assert(it != m_history.begin());
      if (it != m_history.begin())
        --it;
    }
    //assert(timestamp >= it->begin() && timestamp < it->end());
    return std::string(it->data(), it->data() + it->size());
  }

References Slic3r::UndoRedo::ObjectHistory< MutableHistoryInterval >::m_history.

memsize()

template<typename T>

size_t Slic3r::UndoRedo::MutableObjectHistory< T >::memsize ( ) const

inlineoverridevirtual

Implements Slic3r::UndoRedo::ObjectHistoryBase.

                                  {
    size_t memsize = sizeof(*this);
    memsize += m_history.size() * sizeof(MutableHistoryInterval);
    for (const MutableHistoryInterval &interval : m_history)
      memsize += interval.memsize();
    return memsize;
  }

References Slic3r::UndoRedo::ObjectHistory< MutableHistoryInterval >::m_history, and memsize().

Referenced by memsize().

Here is the call graph for this function:

Here is the caller graph for this function:

release_after_timestamp()

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

inlineoverridevirtualinherited

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;
  }

release_before_timestamp()

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

inlineoverridevirtualinherited

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;
  }

release_between_timestamps()

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

inlineoverridevirtualinherited

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;
  }

release_optional()

template<typename T>

size_t Slic3r::UndoRedo::MutableObjectHistory< T >::release_optional ( )

inlineoverridevirtual

Implements Slic3r::UndoRedo::ObjectHistoryBase.

{ return 0; }

restore_optional()

template<typename T>

void Slic3r::UndoRedo::MutableObjectHistory< T >::restore_optional ( )

inlineoverridevirtual

Implements Slic3r::UndoRedo::ObjectHistoryBase.

{}

save()

template<typename T>

void Slic3r::UndoRedo::MutableObjectHistory< T >::save ( size_t active_snapshot_time, size_t current_time, const std::string & data )

inline

                                                                                     {
    assert(m_history.empty() || m_history.back().end() <= active_snapshot_time);
    if (m_history.empty() || m_history.back().end() < active_snapshot_time) {
      if (! m_history.empty() && m_history.back().matches(data))
        // Share the previous data by reference counting.
        m_history.emplace_back(Interval(current_time, current_time + 1), m_history.back());
      else
        // Allocate new data.
        m_history.emplace_back(Interval(current_time, current_time + 1), data);
    } else {
      assert(! m_history.empty());
      assert(m_history.back().end() == active_snapshot_time);
      if (m_history.back().matches(data))
        // Just extend the last interval using the old data.
        m_history.back().extend_end(current_time + 1);
      else
        // Allocate new data time continuous with the previous data.
        m_history.emplace_back(Interval(active_snapshot_time, current_time + 1), data);
    }
  }

References Slic3r::UndoRedo::ObjectHistory< MutableHistoryInterval >::m_history.

try_save_timestamp()

template<typename T>

bool Slic3r::UndoRedo::MutableObjectHistory< T >::try_save_timestamp ( size_t active_snapshot_time, size_t current_time, uint64_t timestamp )

inline

                                                                                                {
    assert(m_history.empty() || m_history.back().end() <= active_snapshot_time);
    if (! m_history.empty() && m_history.back().matches_timestamp(timestamp)) {
      if (m_history.back().end() < active_snapshot_time)
        // Share the previous data by reference counting.
        m_history.emplace_back(Interval(current_time, current_time + 1), m_history.back());
      else {
        assert(m_history.back().end() == active_snapshot_time);
        // Just extend the last interval using the old data.
        m_history.back().extend_end(current_time + 1);
      }
      return true;
    }
    // The timestamp is not valid, the caller has to call this->save() with the serialized data.
    return false;
  }

References Slic3r::UndoRedo::ObjectHistory< MutableHistoryInterval >::m_history.

valid()

template<typename T>

bool Slic3r::UndoRedo::MutableObjectHistory< T >::valid ( )

overridevirtual

Implements Slic3r::UndoRedo::ObjectHistoryBase.

{
  // Verify that the history intervals are sorted and do not overlap, and that the data reference counters are correct.
  if (! m_history.empty()) {
    std::map<const char*, size_t> refcntrs;
    assert(m_history.front().data() != nullptr);
    ++ refcntrs[m_history.front().data()];
    for (size_t i = 1; i < m_history.size(); ++ i) {
      assert(m_history[i - 1].interval().strictly_before(m_history[i].interval()));
      ++ refcntrs[m_history[i].data()];
    }
    for (const auto &hi : m_history) {
      assert(hi.data() != nullptr);
      assert(refcntrs[hi.data()] == hi.refcnt());
    }
  }
  return true;
}

References Slic3r::UndoRedo::ObjectHistory< MutableHistoryInterval >::m_history.

Member Data Documentation

m_history

std::vector<MutableHistoryInterval> Slic3r::UndoRedo::ObjectHistory< MutableHistoryInterval >::m_history

protectedinherited

Referenced by Slic3r::UndoRedo::MutableObjectHistory< T >::load(), Slic3r::UndoRedo::MutableObjectHistory< T >::memsize(), Slic3r::UndoRedo::MutableObjectHistory< T >::save(), Slic3r::UndoRedo::MutableObjectHistory< T >::try_save_timestamp(), and Slic3r::UndoRedo::MutableObjectHistory< T >::valid().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/Utils/UndoRedo.cpp