itkVectorDataContainer.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright UMC Utrecht and contributors
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
 
/*=========================================================================
 
  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 ) override;
 
};
 
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkVectorDataContainer.hxx"
#endif
 
#endif // end __itkVectorDataContainer_h