#include <SparseField.h>

Public Types
typedef SparseField< Data_T >	class_type
Public Member Functions
	iterator (class_type &field, const Box3i &window, const V3i &currentPos, int blockOrder)
bool	operator!= (const iterator &rhs) const
Data_T &	operator* ()
const iterator &	operator++ ()
Data_T *	operator-> ()
bool	operator== (const iterator &rhs) const
Public Attributes
int	x
int	y
int	z
Private Types
typedef Sparse::SparseBlock < Data_T >	Block
Private Member Functions
void	setupNextBlock (int i, int j, int k)
	Convenience.
Private Attributes
int	m_blockI
	Current block index.
int	m_blockId
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.
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.
Data_T *	m_p
	Current pointed-to element.
Box3i	m_window
	Window to traverse.

Detailed Description

template<class Data_T>
class SparseField< Data_T >::iterator

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

Definition at line 803 of file SparseField.h.

Member Typedef Documentation

template<class Data_T>

typedef SparseField<Data_T> SparseField< Data_T >::iterator::class_type

Definition at line 806 of file SparseField.h.

template<class Data_T>

typedef Sparse::SparseBlock<Data_T> SparseField< Data_T >::iterator::Block [private]

Definition at line 894 of file SparseField.h.

Constructor & Destructor Documentation

template<class Data_T>

SparseField< Data_T >::iterator::iterator	(	class_type &	field,
		const Box3i &	window,
		const V3i &	currentPos,
		int	blockOrder
	)		`[inline]`

Definition at line 807 of file SparseField.h.

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

Member Function Documentation

template<class Data_T>

const iterator& SparseField< Data_T >::iterator::operator++ ( ) [inline]

Definition at line 816 of file SparseField.h.

References SparseField< Data_T >::m_blockOrder, and WritableField< Data_T >::iterator::x.

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

template<class Data_T>

bool SparseField< Data_T >::iterator::operator== ( const iterator & rhs ) const [inline]

Definition at line 849 of file SparseField.h.

References WritableField< Data_T >::iterator::x, WritableField< Data_T >::iterator::y, and WritableField< Data_T >::iterator::z.

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

template<class Data_T>

bool SparseField< Data_T >::iterator::operator!= ( const iterator & rhs ) const [inline]

Definition at line 853 of file SparseField.h.

References WritableField< Data_T >::iterator::x, WritableField< Data_T >::iterator::y, and WritableField< Data_T >::iterator::z.

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

template<class Data_T>

Data_T& SparseField< Data_T >::iterator::operator* ( ) [inline]

Definition at line 857 of file SparseField.h.

References Msg::print(), and Msg::SevWarning.

  {
    if (m_field->m_fileManager) {
      assert(false && "Dereferencing iterator on a dynamic-read sparse field");
      Msg::print(Msg::SevWarning, "Dereferencing iterator on a dynamic-read "
                "sparse field");
      return *m_p;      
    }
    // If the block is currently empty, we must allocate it
    if (m_isEmptyBlock) {
      // Touch the voxel to allocate the block
      m_field->lvalue(x, y, z);
      // Set up the block again
      setupNextBlock(x, y, z);
    }
    return *m_p;
  }

template<class Data_T>

Data_T* SparseField< Data_T >::iterator::operator-> ( ) [inline]

Definition at line 874 of file SparseField.h.

References Msg::print(), and Msg::SevWarning.

  {
    if (m_field->m_fileManager) {
      assert(false && "Dereferencing iterator on a dynamic-read sparse field");
      Msg::print(Msg::SevWarning, "Dereferencing iterator on a dynamic-read "
                "sparse field");
      return m_p;      
    }
    // If the block is currently empty, we must allocate it
    if (m_isEmptyBlock) {
      // Touch the voxel to allocate the block
      m_field->lvalue(x, y, z);
      // Set up the block again
      setupNextBlock(x, y, z);
    }
    return m_p;
  }

template<class Data_T>

void SparseField< Data_T >::iterator::setupNextBlock	(	int	i,
		int	j,
		int	k
	)		`[inline, private]`

Convenience.

Definition at line 896 of file SparseField.h.

References Sparse::SparseBlock< Data_T >::emptyValue, Sparse::SparseBlock< Data_T >::isAllocated, SparseField< Data_T >::m_blockOrder, and Sparse::SparseBlock< Data_T >::value().

  {
    m_field->applyDataWindowOffset(i, j, k);
    m_field->getBlockCoord(i, j, k, m_blockI, m_blockJ, m_blockK);
    m_blockId = m_field->blockId(m_blockI, m_blockJ, m_blockK);
    if (m_blockId >= m_field->m_blockXYSize * m_field->m_blockRes.z) {
      m_isEmptyBlock = true;
      return;
    }
    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) {
      m_p = &block.value(vi, vj, vk, m_blockOrder);
      m_isEmptyBlock = false;
    } else {
      m_p = &block.emptyValue;
      m_isEmptyBlock = true;
    }
  }