CollectorHeapIterator.h [plain text]
#include "config.h"
#include "Collector.h"
#ifndef CollectorHeapIterator_h
#define CollectorHeapIterator_h
namespace JSC {
class CollectorHeapIterator {
public:
bool operator!=(const CollectorHeapIterator& other);
JSCell* operator*() const;
protected:
CollectorHeapIterator(CollectorHeap&, size_t startBlock, size_t startCell);
void advance(size_t cellsPerBlock);
CollectorHeap& m_heap;
size_t m_block;
size_t m_cell;
};
class LiveObjectIterator : public CollectorHeapIterator {
public:
LiveObjectIterator(CollectorHeap&, size_t startBlock, size_t startCell = 0);
LiveObjectIterator& operator++();
};
class DeadObjectIterator : public CollectorHeapIterator {
public:
DeadObjectIterator(CollectorHeap&, size_t startBlock, size_t startCell = 0);
DeadObjectIterator& operator++();
};
class ObjectIterator : public CollectorHeapIterator {
public:
ObjectIterator(CollectorHeap&, size_t startBlock, size_t startCell = 0);
ObjectIterator& operator++();
};
inline CollectorHeapIterator::CollectorHeapIterator(CollectorHeap& heap, size_t startBlock, size_t startCell)
: m_heap(heap)
, m_block(startBlock)
, m_cell(startCell)
{
}
inline bool CollectorHeapIterator::operator!=(const CollectorHeapIterator& other)
{
return m_block != other.m_block || m_cell != other.m_cell;
}
inline JSCell* CollectorHeapIterator::operator*() const
{
return reinterpret_cast<JSCell*>(m_heap.blocks[m_block]->cells + m_cell);
}
inline void CollectorHeapIterator::advance(size_t cellsPerBlock)
{
++m_cell;
if (m_cell == cellsPerBlock) {
m_cell = 0;
++m_block;
}
}
inline LiveObjectIterator::LiveObjectIterator(CollectorHeap& heap, size_t startBlock, size_t startCell)
: CollectorHeapIterator(heap, startBlock, startCell - 1)
{
++(*this);
}
inline LiveObjectIterator& LiveObjectIterator::operator++()
{
if (m_block < m_heap.nextBlock || m_cell < m_heap.nextCell) {
advance(HeapConstants::cellsPerBlock);
return *this;
}
do {
advance(HeapConstants::cellsPerBlock);
} while (m_block < m_heap.usedBlocks && !m_heap.blocks[m_block]->marked.get(m_cell));
return *this;
}
inline DeadObjectIterator::DeadObjectIterator(CollectorHeap& heap, size_t startBlock, size_t startCell)
: CollectorHeapIterator(heap, startBlock, startCell - 1)
{
++(*this);
}
inline DeadObjectIterator& DeadObjectIterator::operator++()
{
do {
advance(HeapConstants::cellsPerBlock);
ASSERT(m_block > m_heap.nextBlock || (m_block == m_heap.nextBlock && m_cell >= m_heap.nextCell));
} while (m_block < m_heap.usedBlocks && m_heap.blocks[m_block]->marked.get(m_cell));
return *this;
}
inline ObjectIterator::ObjectIterator(CollectorHeap& heap, size_t startBlock, size_t startCell)
: CollectorHeapIterator(heap, startBlock, startCell - 1)
{
++(*this);
}
inline ObjectIterator& ObjectIterator::operator++()
{
advance(HeapConstants::cellsPerBlock);
return *this;
}
}
#endif // CollectorHeapIterator_h