#include <SparseField.h>

Public Types
typedef SparseField< Data_T >	class_type

Public Member Functions
	const_iterator (const class_type &field, const Box3i &window, const V3i &currentPos, int blockOrder)
template<class Iter_T>
bool	operator!= (const Iter_T &rhs) const
const Data_T &	operator* () const
const const_iterator &	operator++ ()
const Data_T *	operator-> () const
template<class Iter_T>
bool	operator== (const Iter_T &rhs) const
	~const_iterator ()

Public Attributes
int	x
	Current x/y/z coord.
int	y
int	z

Private Types
typedef Sparse::SparseBlock< Data_T >	Block

Private Member Functions
void	setupNextBlock (int i, int j, int k)

Private Attributes
int	m_blockI
	Current block index.
int	m_blockId
bool	m_blockIsActivated
	Used with delayed-load fields. Check if we've already activated the current blocks.
int	m_blockJ
int	m_blockK
int	m_blockOrder
	Block size.
int	m_blockStepsTicker
	Ticker for how many more steps to take before resetting the pointer.
const class_type *	m_field
	Reference to field we're traversing.
bool	m_isEmptyBlock
	Whether we're at an empty block and we don't increment m_p.
SparseFileManager *	m_manager
	Pointer to the singleton file manager.
const Data_T *	m_p
	Current pointed-to element.
Box3i	m_window
	Window to traverse.

Detailed Description

template<class Data_T>
class SparseField< Data_T >::const_iterator

Todo: Code duplication between this and iterator!!!!!!!!!!!!!!!!!!!!!!

Definition at line 885 of file SparseField.h.

Member Typedef Documentation

◆ class_type

template<class Data_T>

typedef SparseField<Data_T> SparseField< Data_T >::const_iterator::class_type

Definition at line 897 of file SparseField.h.

◆ Block

template<class Data_T>

typedef Sparse::SparseBlock<Data_T> SparseField< Data_T >::const_iterator::Block

private

Definition at line 994 of file SparseField.h.

Constructor & Destructor Documentation

◆ const_iterator()

template<class Data_T>

SparseField< Data_T >::const_iterator::const_iterator	(	const class_type &	field,
		const Box3i &	window,
		const V3i &	currentPos,
		int	blockOrder )

inline

Definition at line 898 of file SparseField.h.

    : x(currentPos.x), y(currentPos.y), z(currentPos.z),
      m_p(NULL), m_blockIsActivated(false),
      m_blockStepsTicker(0), m_blockOrder(blockOrder),
      m_blockId(-1), m_window(window), m_field(&field)
  {
    m_manager = m_field->m_fileManager;
    setupNextBlock(x, y, z);
  }

References SparseField< Data_T >::blockOrder(), m_blockId, m_blockIsActivated, m_blockOrder, m_blockStepsTicker, m_field, m_manager, m_p, m_window, setupNextBlock(), x, y, and z.

Referenced by operator++().

◆ ~const_iterator()

template<class Data_T>

SparseField< Data_T >::const_iterator::~const_iterator ( )

inline

Definition at line 909 of file SparseField.h.

                    {
    if (m_manager && m_blockId >= 0 &&
        m_blockId < static_cast<int>(m_field->m_numBlocks)) {
      if (m_field->m_blocks[m_blockId].isAllocated)
        m_manager->decBlockRef<Data_T>(m_field->m_fileId, m_blockId);
    }
  }

References m_blockId, m_field, and m_manager.

Member Function Documentation

◆ operator++()

template<class Data_T>

const const_iterator & SparseField< Data_T >::const_iterator::operator++ ( )

inline

Definition at line 916 of file SparseField.h.

  {
    bool resetPtr = false;
    // Check against end of data window
    if (x == m_window.max.x) {
      if (y == m_window.max.y) {
        x = m_window.min.x;
        y = m_window.min.y;
        ++z;
        resetPtr = true;
      } else {
        x = m_window.min.x;
        ++y;
        resetPtr = true;
      }
    } else {
      ++x;
    }
    // These can both safely be incremented here
    ++m_blockStepsTicker;
    // ... but only step forward if we're in a non-empty block
    if (!m_isEmptyBlock && (!m_manager || m_blockIsActivated))
      ++m_p;
    // Check if we've reached the end of this block
    if (m_blockStepsTicker == (1 << m_blockOrder))
      resetPtr = true;
    if (resetPtr) {
      // If we have, we need to reset the current block, etc.
      m_blockStepsTicker = 0;
      setupNextBlock(x, y, z);
    }
    return *this;
  }

References const_iterator(), m_blockIsActivated, m_blockOrder, m_blockStepsTicker, m_isEmptyBlock, m_manager, m_p, m_window, setupNextBlock(), x, y, and z.

◆ operator==()

template<class Data_T>

template<class Iter_T>

bool SparseField< Data_T >::const_iterator::operator== ( const Iter_T & rhs ) const

inline

Definition at line 950 of file SparseField.h.

  {
    return x == rhs.x && y == rhs.y && z == rhs.z;
  }

References x, y, and z.

◆ operator!=()

template<class Data_T>

template<class Iter_T>

bool SparseField< Data_T >::const_iterator::operator!= ( const Iter_T & rhs ) const

inline

Definition at line 955 of file SparseField.h.

  {
    return x != rhs.x || y != rhs.y || z != rhs.z;
  }

References x, y, and z.

◆ operator*()

template<class Data_T>

const Data_T & SparseField< Data_T >::const_iterator::operator* ( ) const

inline

Definition at line 959 of file SparseField.h.

  {
    if (!m_isEmptyBlock && m_manager && !m_blockIsActivated) {
      m_manager->activateBlock<Data_T>(m_field->m_fileId, m_blockId);
      m_blockIsActivated = true;
      const Block &block = m_field->m_blocks[m_blockId];
      int vi, vj, vk;
      m_field->getVoxelInBlock(x, y, z, vi, vj, vk);
      m_p = &block.value(vi, vj, vk, m_blockOrder);
    }
    return *m_p;
  }

References m_blockId, m_blockIsActivated, m_blockOrder, m_field, m_isEmptyBlock, m_manager, m_p, Sparse::SparseBlock< Data_T >::value(), x, y, and z.

◆ operator->()

template<class Data_T>

const Data_T * SparseField< Data_T >::const_iterator::operator-> ( ) const

inline

Definition at line 971 of file SparseField.h.

  {
    if (!m_isEmptyBlock && m_manager && !m_blockIsActivated) {
      SparseFileManager *manager = m_field->m_fileManager;
      manager->activateBlock<Data_T>(m_field->m_fileId, m_blockId);
      m_blockIsActivated = true;
      const Block &block = m_field->m_blocks[m_blockId];
      int vi, vj, vk;
      m_field->getVoxelInBlock(x, y, z, vi, vj, vk);
      m_p = &block.value(vi, vj, vk, m_blockOrder);
    }
    return m_p;
  }

References SparseFileManager::activateBlock(), m_blockId, m_blockIsActivated, m_blockOrder, m_field, m_isEmptyBlock, m_manager, m_p, Sparse::SparseBlock< Data_T >::value(), x, y, and z.

◆ setupNextBlock()

template<class Data_T>

void SparseField< Data_T >::const_iterator::setupNextBlock	(	int	i,
		int	j,
		int	k )

inlineprivate

Definition at line 998 of file SparseField.h.

  {
    m_field->applyDataWindowOffset(i, j, k);
    m_field->getBlockCoord(i, j, k, m_blockI, m_blockJ, m_blockK);
    int oldBlockId = m_blockId;
    m_blockId = m_field->blockId(m_blockI, m_blockJ, m_blockK);
    if (m_manager && oldBlockId != m_blockId &&
        oldBlockId >= 0 &&
        oldBlockId < static_cast<int>(m_field->m_numBlocks) &&
        m_field->m_blocks[oldBlockId].isAllocated) {
      m_manager->decBlockRef<Data_T>(m_field->m_fileId, oldBlockId);
    }
    if (m_blockId >= m_field->m_blockXYSize * m_field->m_blockRes.z) {
      m_isEmptyBlock = true;
      return;
    }
 
    const Block &block = m_field->m_blocks[m_blockId];
    int vi, vj, vk;
    m_field->getVoxelInBlock(i, j, k, vi, vj, vk);
    m_blockStepsTicker = vi;
    if (block.isAllocated) {
      if (m_manager && oldBlockId != m_blockId && m_blockId >= 0) {
        m_manager->incBlockRef<Data_T>(m_field->m_fileId, m_blockId);
        // this is a managed field, so the block may not be loaded
        // yet, so don't bother setting m_p yet (it'll get set in the
        // * and -> operators when the block is activated)
      } else {
        // only set m_p to the voxel's address if this is not a
        // managed field, i.e., if the data is already in memory.
        m_p = &block.value(vi, vj, vk, m_blockOrder);
      }
      m_isEmptyBlock = false;
    } else {
      m_p = &block.emptyValue;
      m_isEmptyBlock = true;
    }
    if (m_field->m_fileManager) {
      m_blockIsActivated = false;
    }
  }