itkFixedArray.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkFixedArray.h,v $
  Language:  C++
  Date:      $Date: 2005/08/08 21:36:16 $
  Version:   $Revision: 1.36 $

  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 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;
  };
  
  class ConstReverseIterator
  {
  public:
    explicit ConstReverseIterator(ConstIterator i): m_Iterator(i) {}
    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]);

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

  ~FixedArray();
  
  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();
    for(Iterator i = this->Begin() ; 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)
{
  os << "[";
  if ( VLength == 1 )
    {
    os << arr[0] ;
    }
  else
    {
    for (int i=0; i < static_cast<int>(VLength) - 1; ++i)
      {
      os << arr[i] << ", ";
      }
    os << arr[VLength-1];
    }
  os << "]";
  return os;
}

} // namespace itk

#ifdef _MSC_VER
# pragma warning (pop)
#endif

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkFixedArray.txx"
#endif

#endif

---