itkVectorDataContainer.h

Go to the documentation of this file.

/*======================================================================

  This file is part of the elastix software.

  Copyright (c) University Medical Center Utrecht. All rights reserved.
  See src/CopyrightElastix.txt or http://elastix.isi.uu.nl/legal.php for
  details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE. See the above copyright notices for more information.

======================================================================*/

/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile$
  Language:  C++
  Date:      $Date: 2008-04-15 19:54:41 +0200 (Tue, 15 Apr 2008) $
  Version:   $Revision: 1573 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __itkVectorDataContainer_h
#define __itkVectorDataContainer_h

#include "itkDataObject.h"
#include "itkObjectFactory.h"

#include <utility>
#include <vector>

namespace itk
{

template<
typename TElementIdentifier,
typename TElement
>
class VectorDataContainer :
  public DataObject,
  public std::vector< TElement >
{
public:

  typedef VectorDataContainer        Self;
  typedef DataObject                 Superclass;
  typedef SmartPointer< Self >       Pointer;
  typedef SmartPointer< const Self > ConstPointer;

  typedef TElementIdentifier ElementIdentifier;
  typedef TElement           Element;

private:

  typedef std::vector< Element >              VectorType;
  typedef typename VectorType::size_type      size_type;
  typedef typename VectorType::iterator       VectorIterator;
  typedef typename VectorType::const_iterator VectorConstIterator;

protected:

  VectorDataContainer() :
    DataObject(), VectorType() {}
  VectorDataContainer( size_type n ) :
    DataObject(), VectorType( n ) {}
  VectorDataContainer( size_type n, const Element & x ) :
    DataObject(), VectorType( n, x ) {}
  VectorDataContainer( const Self & r ) :
    DataObject(), VectorType( r ) {}
  template< typename InputIterator >
  VectorDataContainer( InputIterator first, InputIterator last ) :
    DataObject(), VectorType( first, last ) {}

public:

  typedef VectorType STLContainerType;

  itkNewMacro( Self );

  itkTypeMacro( VectorDataContainer, DataObject );

  class Iterator;
  class ConstIterator;

  STLContainerType & CastToSTLContainer()
  {
    return dynamic_cast< STLContainerType & >( *this );
  }


  const STLContainerType & CastToSTLConstContainer() const
  {
    return dynamic_cast< const STLContainerType & >( *this );
  }


  friend class Iterator;
  friend class ConstIterator;

  class Iterator
  {
public:

    Iterator() {}
    Iterator( size_type d, const VectorIterator & i ) : m_Pos( d ), m_Iter( i ) {}

    Iterator & operator*()    { return *this; }
    Iterator * operator->()   { return this; }
    Iterator & operator++()   { ++m_Pos; ++m_Iter; return *this; }
    Iterator operator++( int ) { Iterator temp( *this ); ++m_Pos; ++m_Iter; return temp; }
    Iterator operator+=( int j ){ m_Pos += j; m_Iter += j; return *this; }
    Iterator operator-=( int j ){ m_Pos -= j; m_Iter -= j; return *this; }
    Iterator & operator--()   { --m_Pos; --m_Iter; return *this; }
    Iterator operator--( int ) { Iterator temp( *this ); --m_Pos; --m_Iter; return temp; }

    bool operator==( const Iterator & r ) const { return m_Iter == r.m_Iter; }
    bool operator!=( const Iterator & r ) const { return m_Iter != r.m_Iter; }
    bool operator==( const ConstIterator & r ) const { return m_Iter == r.m_Iter; }
    bool operator!=( const ConstIterator & r ) const { return m_Iter != r.m_Iter; }

    ElementIdentifier Index( void ) const { return static_cast< ElementIdentifier >( m_Pos ); }

    Element & Value( void ) const { return *m_Iter; }

private:

    size_type      m_Pos;
    VectorIterator m_Iter;
    friend class ConstIterator;
  };

  class ConstIterator
  {
public:

    ConstIterator() {}
    ConstIterator( size_type d, const VectorConstIterator & i ) : m_Pos( d ), m_Iter( i ) {}
    ConstIterator( const Iterator & r ) { m_Pos = r.m_Pos; m_Iter = r.m_Iter; }

    ConstIterator & operator*()    { return *this; }
    ConstIterator * operator->()   { return this; }
    ConstIterator & operator++()   { ++m_Pos; ++m_Iter; return *this; }
    ConstIterator operator++( int ) { ConstIterator temp( *this ); ++m_Pos; ++m_Iter; return temp; }
    ConstIterator operator+=( int j ){ m_Pos += j; m_Iter += j; return *this; }
    ConstIterator operator-=( int j ){ m_Pos -= j; m_Iter -= j; return *this; }
    ConstIterator & operator--()   { --m_Pos; --m_Iter; return *this; }
    ConstIterator operator--( int ) { ConstIterator temp( *this ); --m_Pos; --m_Iter; return temp; }

    ConstIterator & operator=( const Iterator & r ) { m_Pos = r.m_Pos; m_Iter = r.m_Iter; return *this; }

    bool operator==( const Iterator & r ) const { return m_Iter == r.m_Iter; }
    bool operator!=( const Iterator & r ) const { return m_Iter != r.m_Iter; }
    bool operator==( const ConstIterator & r ) const { return m_Iter == r.m_Iter; }
    bool operator!=( const ConstIterator & r ) const { return m_Iter != r.m_Iter; }

    ElementIdentifier Index( void ) const { return static_cast< ElementIdentifier >( m_Pos ); }

    const Element & Value( void ) const { return *m_Iter; }

private:

    size_type           m_Pos;
    VectorConstIterator m_Iter;
    friend class Iterator;
  };

  /* Declare the public interface routines. */

  Element & ElementAt( ElementIdentifier );

  const Element & ElementAt( ElementIdentifier ) const;

  Element & CreateElementAt( ElementIdentifier );

  Element GetElement( ElementIdentifier ) const;

  void SetElement( ElementIdentifier, Element );

  void InsertElement( ElementIdentifier, Element );

  bool IndexExists( ElementIdentifier ) const;

  bool GetElementIfIndexExists( ElementIdentifier, Element * ) const;

  void CreateIndex( ElementIdentifier );

  void DeleteIndex( ElementIdentifier );

  ConstIterator Begin( void ) const;

  ConstIterator End( void ) const;

  Iterator Begin( void );

  Iterator End( void );

  unsigned long Size( void ) const;

  void Reserve( ElementIdentifier );

  void Squeeze( void );

  void Initialize( void );

};

} // end namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkVectorDataContainer.hxx"
#endif

#endif // end __itkVectorDataContainer_h