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

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

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

Public Member Functions
	ImmutableObjectHistory (std::shared_ptr< const T > shared_object, bool optional)
	~ImmutableObjectHistory () override
bool	is_mutable () const override
bool	is_immutable () const override
bool	is_optional () const override
const void *	immutable_object_ptr () const override
size_t	memsize () const override
void	save (size_t active_snapshot_time, size_t current_time)
bool	has_snapshot (size_t timestamp)
size_t	release_optional () override
void	restore_optional () override
bool	is_serialized () const
const std::string &	serialized_data () const
std::shared_ptr< const T > &	shared_ptr (StackImpl &stack)
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

Protected Attributes
std::vector< Interval >	m_history

Private Attributes
std::shared_ptr< const T >	m_shared_object
bool	m_optional
std::string	m_serialized

Detailed Description

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

Constructor & Destructor Documentation

ImmutableObjectHistory()

template<typename T>

Slic3r::UndoRedo::ImmutableObjectHistory< T >::ImmutableObjectHistory ( std::shared_ptr< const T > shared_object, bool optional )

inline

: m_shared_object(shared_object), m_optional(optional) {}

References m_optional, and m_shared_object.

~ImmutableObjectHistory()

template<typename T>

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

inlineoverride

{}

Member Function Documentation

empty()

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

inlineoverridevirtualinherited

Implements Slic3r::UndoRedo::ObjectHistoryBase.

{ return m_history.empty(); }

has_snapshot()

template<typename T>

bool Slic3r::UndoRedo::ImmutableObjectHistory< T >::has_snapshot ( size_t timestamp )

inline

                                      {
    if (m_history.empty())
      return false;
    auto it = std::lower_bound(m_history.begin(), m_history.end(), Interval(timestamp, timestamp));
    if (it == m_history.end() || it->begin() > timestamp) {
      if (it == m_history.begin())
        return false;
      -- it;
    }
    return timestamp >= it->begin() && timestamp < it->end();
  }

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

immutable_object_ptr()

template<typename T>

const void * Slic3r::UndoRedo::ImmutableObjectHistory< T >::immutable_object_ptr ( ) const

inlineoverridevirtual

Reimplemented from Slic3r::UndoRedo::ObjectHistoryBase.

{ return (const void*)m_shared_object.get(); }

References m_shared_object.

is_immutable()

template<typename T>

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

inlineoverridevirtual

Implements Slic3r::UndoRedo::ObjectHistoryBase.

{ return true; }

is_mutable()

template<typename T>

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

inlineoverridevirtual

Implements Slic3r::UndoRedo::ObjectHistoryBase.

{ return false; }

is_optional()

template<typename T>

bool Slic3r::UndoRedo::ImmutableObjectHistory< T >::is_optional ( ) const

inlineoverridevirtual

Reimplemented from Slic3r::UndoRedo::ObjectHistoryBase.

{ return m_optional; }

References m_optional.

is_serialized()

template<typename T>

bool Slic3r::UndoRedo::ImmutableObjectHistory< T >::is_serialized ( ) const

inline

{ return m_shared_object.get() == nullptr; }

References m_shared_object.

Referenced by memsize(), and release_optional().

Here is the caller graph for this function:

memsize()

template<typename T>

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

inlineoverridevirtual

Implements Slic3r::UndoRedo::ObjectHistoryBase.

                                  {
    size_t memsize = sizeof(*this);
    if (this->is_serialized())
      memsize += m_serialized.size();
    else if (m_shared_object.use_count() == 1)
      // Only count the shared object's memsize into the total Undo / Redo stack memsize if it is referenced from the Undo / Redo stack only.
      memsize += m_shared_object->memsize();
    memsize += m_history.size() * sizeof(Interval);
    return memsize;
  }

References is_serialized(), Slic3r::UndoRedo::ObjectHistory< Interval >::m_history, m_serialized, m_shared_object, 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< Interval >::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< Interval >::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< Interval >::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::ImmutableObjectHistory< T >::release_optional ( )

inlineoverridevirtual

Implements Slic3r::UndoRedo::ObjectHistoryBase.

                                     {
    size_t mem_released = 0;
    if (m_optional) {
      bool released = false;
      if (this->is_serialized()) {
        mem_released += m_serialized.size();
        m_serialized.clear();
        released = true;
      } else if (m_shared_object.use_count() == 1) {
        mem_released += m_shared_object->memsize();
        m_shared_object.reset();
        released = true;
      }
      if (released) {
        mem_released += m_history.size() * sizeof(Interval);
        m_history.clear();
      }
    } else if (m_shared_object.use_count() == 1) {
      // The object is in memory, but it is not shared with the scene. Let the object decide whether there is any optional data to release.
      const_cast<T*>(m_shared_object.get())->release_optional();
    }
    return mem_released;
  }

References is_serialized(), Slic3r::UndoRedo::ObjectHistory< Interval >::m_history, m_optional, m_serialized, and m_shared_object.

Here is the call graph for this function:

restore_optional()

template<typename T>

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

inlineoverridevirtual

Implements Slic3r::UndoRedo::ObjectHistoryBase.

                                   {
    if (m_shared_object.use_count() == 1)
      const_cast<T*>(m_shared_object.get())->restore_optional();
  }

References m_shared_object.

save()

template<typename T>

void Slic3r::UndoRedo::ImmutableObjectHistory< T >::save ( size_t active_snapshot_time, size_t current_time )

inline

                                                              {
    assert(m_history.empty() || m_history.back().end() <= active_snapshot_time ||
      // The snapshot of an immutable object may have already been taken from another mutable object.
      (m_history.back().begin() <= active_snapshot_time && m_history.back().end() == current_time + 1));
    if (m_history.empty() || m_history.back().end() < active_snapshot_time)
      m_history.emplace_back(active_snapshot_time, current_time + 1);
    else
      m_history.back().extend_end(current_time + 1);
  }

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

Referenced by Slic3r::UndoRedo::StackImpl::save_immutable_object().

Here is the caller graph for this function:

serialized_data()

template<typename T>

const std::string & Slic3r::UndoRedo::ImmutableObjectHistory< T >::serialized_data ( ) const

inline

{ return m_serialized; }

References m_serialized.

shared_ptr()

template<typename T>

std::shared_ptr< const T > & Slic3r::UndoRedo::ImmutableObjectHistory< T >::shared_ptr

(

StackImpl &

stack

)

{
  if (m_shared_object.get() == nullptr && ! m_serialized.empty()) {
    // Deserialize the object.
    std::istringstream iss(m_serialized);
    {
      Slic3r::UndoRedo::InputArchive archive(stack, iss);
      typedef typename std::remove_const<T>::type Type;
      std::unique_ptr<Type> mesh(new Type());
      archive(*mesh.get());
      m_shared_object = std::move(mesh);
    }
  }
  return m_shared_object;
}

References m_serialized, and m_shared_object.

valid()

template<typename T>

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

overridevirtual

Implements Slic3r::UndoRedo::ObjectHistoryBase.

{
  // The immutable object content is captured either by a shared object, or by its serialization, but not both.
  assert(! m_shared_object == ! m_serialized.empty());
  // Verify that the history intervals are sorted and do not overlap.
  if (! m_history.empty())
    for (size_t i = 1; i < m_history.size(); ++ i)
      assert(m_history[i - 1].strictly_before(m_history[i]));
  return true;
}

References Slic3r::UndoRedo::ObjectHistory< Interval >::m_history, m_serialized, and m_shared_object.

Member Data Documentation

m_history

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

protectedinherited

Referenced by Slic3r::UndoRedo::ImmutableObjectHistory< T >::has_snapshot(), Slic3r::UndoRedo::ImmutableObjectHistory< T >::memsize(), Slic3r::UndoRedo::ImmutableObjectHistory< T >::release_optional(), Slic3r::UndoRedo::ImmutableObjectHistory< T >::save(), and Slic3r::UndoRedo::ImmutableObjectHistory< T >::valid().

m_optional

template<typename T>

bool Slic3r::UndoRedo::ImmutableObjectHistory< T >::m_optional

private

Referenced by ImmutableObjectHistory(), is_optional(), and release_optional().

m_serialized

template<typename T>

std::string Slic3r::UndoRedo::ImmutableObjectHistory< T >::m_serialized

private

Referenced by memsize(), release_optional(), serialized_data(), shared_ptr(), and valid().

m_shared_object

template<typename T>

std::shared_ptr<const T> Slic3r::UndoRedo::ImmutableObjectHistory< T >::m_shared_object

private

Referenced by ImmutableObjectHistory(), immutable_object_ptr(), is_serialized(), memsize(), release_optional(), restore_optional(), shared_ptr(), and valid().

---

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

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