itkFixedArray.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkFixedArray.h,v $
  Language:  C++
  Date:      $Date: 2009-11-28 09:15:37 $
  Version:   $Revision: 1.46 $

  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 __itkFixedArray_h
#define __itkFixedArray_h

#include "itkMacro.h"

#ifdef _MSC_VER
# pragma warning (push)
# pragma warning (disable: 4284) // operator-> returning pointer to non-aggregate
#endif

namespace itk
{

template <typename TVector>
struct GetVectorDimension
{
  itkStaticConstMacro(VectorDimension, unsigned int, TVector::Dimension);
}; 


  
template <typename TValueType, unsigned int VLength=3>
class FixedArray
{
public:
  itkStaticConstMacro(Length, unsigned int, VLength);
  
  itkStaticConstMacro(Dimension, unsigned int, VLength);
  
  typedef TValueType  ValueType;
  
  typedef ValueType         CArray[VLength];
  
  typedef ValueType*        Iterator;

  typedef const ValueType*  ConstIterator;

  class ConstReverseIterator;

  class ReverseIterator
    {
    public:
      explicit ReverseIterator(Iterator i): m_Iterator(i) {}
      Iterator operator++()        { return --m_Iterator; }
      Iterator operator++(int)     { return m_Iterator--; }
      Iterator operator--()        { return ++m_Iterator; }
      Iterator operator--(int)     { return m_Iterator++; }
      Iterator operator->() const  { return (m_Iterator-1); }
      ValueType& operator*() const { return *(m_Iterator-1); }
      bool operator!=(const ReverseIterator &rit) const {return m_Iterator != rit.m_Iterator;}
      bool operator==(const ReverseIterator &rit) const {return m_Iterator == rit.m_Iterator;}
    private:
      Iterator m_Iterator;
      friend class ConstReverseIterator;
    };
  
  class ConstReverseIterator
    {
    public:
      explicit ConstReverseIterator(ConstIterator i): m_Iterator(i) {}
      ConstReverseIterator(const ReverseIterator& rit) { m_Iterator = rit.m_Iterator; }
      ConstIterator operator++()         { return --m_Iterator; }
      ConstIterator operator++(int)      { return m_Iterator--; }
      ConstIterator operator--()         { return ++m_Iterator; }
      ConstIterator operator--(int)      { return m_Iterator++; }
      ConstIterator operator->() const   { return (m_Iterator-1); }
      const ValueType& operator*() const { return *(m_Iterator-1); }
      bool operator!=(const ConstReverseIterator &rit) const {return m_Iterator != rit.m_Iterator;}
      bool operator==(const ConstReverseIterator &rit) const {return m_Iterator == rit.m_Iterator;}
    private:
      ConstIterator m_Iterator;
    };  
  
  typedef ValueType *        pointer;

  typedef const ValueType*  const_pointer;

  typedef ValueType&        reference;

  typedef const ValueType&  const_reference;
  
  typedef unsigned int   SizeType;
  
public:
  FixedArray();
  FixedArray(const ValueType r[VLength]);
  FixedArray(const ValueType& r);

  template< class TFixedArrayValueType >
  FixedArray(const FixedArray< TFixedArrayValueType, VLength >& r)
    {
    typename FixedArray< TFixedArrayValueType, VLength >::ConstIterator input = r.Begin();
    Iterator i = this->Begin();
    while( i != this->End() ) 
      {
      *i++ = static_cast< TValueType >(*input++);
      }
    }
  

  template< class TFixedArrayValueType >
  FixedArray& operator= (const FixedArray< TFixedArrayValueType, VLength > & r)
    {
    if((void *)r.Begin() == (void *)m_InternalArray) return *this;
    typename FixedArray< TFixedArrayValueType, VLength >::ConstIterator input = r.Begin();
    Iterator i = this->Begin();
    while( i != this->End() ) 
      {
      *i++ = static_cast< TValueType >(*input++);
      }
    return *this;
    }

  FixedArray& operator= (const ValueType r[VLength]);
    
  bool operator==(const FixedArray& r ) const;
  bool operator!=(const FixedArray& r ) const
    { return !operator==(r); }
  
        reference operator[](short index)                { return m_InternalArray[index]; }
  const_reference operator[](short index) const          { return m_InternalArray[index]; }
        reference operator[](unsigned short index)       { return m_InternalArray[index]; }
  const_reference operator[](unsigned short index) const { return m_InternalArray[index]; }
        reference operator[](int index)                  { return m_InternalArray[index]; }
  const_reference operator[](int index) const            { return m_InternalArray[index]; }
        reference operator[](unsigned int index)         { return m_InternalArray[index]; }
  const_reference operator[](unsigned int index) const   { return m_InternalArray[index]; }
        reference operator[](long index)                 { return m_InternalArray[index]; }
  const_reference operator[](long index) const           { return m_InternalArray[index]; }
        reference operator[](unsigned long index)        { return m_InternalArray[index]; }
  const_reference operator[](unsigned long index) const  { return m_InternalArray[index]; }
  
  void SetElement( unsigned short index, const_reference value )
                                  { m_InternalArray[ index ] = value; }
  const_reference GetElement( unsigned short index ) const { return m_InternalArray[index]; }
  
  ValueType* GetDataPointer() { return m_InternalArray; }
  const ValueType* GetDataPointer() const { return m_InternalArray; }
    
  Iterator      Begin();
  ConstIterator Begin() const;
  Iterator      End();
  ConstIterator End() const;
  ReverseIterator      rBegin();
  ConstReverseIterator rBegin() const;
  ReverseIterator      rEnd();
  ConstReverseIterator rEnd() const;
  SizeType      Size() const;
  void Fill(const ValueType&);
    
private:
  CArray  m_InternalArray;
  
public:
 
  static FixedArray Filled(const ValueType&);
};
  
template <typename TValueType, unsigned int VLength>
std::ostream & operator<<(std::ostream &os, const FixedArray<TValueType,VLength> &arr);

} // namespace itk

#ifdef _MSC_VER
# pragma warning (pop)
#endif

// Define instantiation macro for this template.
#define ITK_TEMPLATE_FixedArray(_, EXPORT, x, y) namespace itk { \
  _(2(class EXPORT FixedArray< ITK_TEMPLATE_2 x >)) \
  _(1(EXPORT std::ostream& operator<<(std::ostream&, \
                                      const FixedArray< ITK_TEMPLATE_2 x >&))) \
  namespace Templates { typedef FixedArray< ITK_TEMPLATE_2 x > FixedArray##y; } \
  }

#if ITK_TEMPLATE_EXPLICIT
# include "Templates/itkFixedArray+-.h"
#endif

#if ITK_TEMPLATE_TXX
# include "itkFixedArray.txx"
#endif

#include "itkNumericTraitsFixedArrayPixel.h"

#endif