itkFixedArray.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  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.
 *
 *=========================================================================*/
#ifndef __itkFixedArray_h
#define __itkFixedArray_h

#include "itkMacro.h"

namespace itk
{

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 )
      {
      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]; }
  reference operator[](long long index)                 { return m_InternalArray[index]; }
  const_reference operator[](long long index) const { return m_InternalArray[index]; }
  reference operator[](unsigned long long index)        { return m_InternalArray[index]; }
  const_reference operator[](unsigned long 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

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

#include "itkNumericTraitsFixedArrayPixel.h"

#endif