itkFixedArray.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  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"
#include <algorithm>
#include <array>
 
namespace itk
{
 
template <typename TValue, unsigned int VLength = 3>
class ITK_TEMPLATE_EXPORT FixedArray
{
public:
  static constexpr unsigned int Length = VLength;
 
  static constexpr unsigned int Dimension = VLength;
 
  using ValueType = TValue;
 
  using CArray = ValueType[VLength];
 
  using Iterator = ValueType *;
 
  using ConstIterator = const ValueType *;
 
  class ConstReverseIterator;
 
  class ReverseIterator
  {
  public:
    explicit ReverseIterator(Iterator i)
      : m_Iterator(i)
    {}
    ReverseIterator
    operator++()
    {
      return ReverseIterator(--m_Iterator);
    }
    ReverseIterator
    operator++(int)
    {
      return ReverseIterator(m_Iterator--);
    }
    ReverseIterator
    operator--()
    {
      return ReverseIterator(++m_Iterator);
    }
    ReverseIterator
    operator--(int)
    {
      return ReverseIterator(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; }
    ConstReverseIterator
    operator++()
    {
      return ConstReverseIterator(--m_Iterator);
    }
    ConstReverseIterator
    operator++(int)
    {
      return ConstReverseIterator(m_Iterator--);
    }
    ConstReverseIterator
    operator--()
    {
      return ConstReverseIterator(++m_Iterator);
    }
    ConstReverseIterator
    operator--(int)
    {
      return ConstReverseIterator(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;
  };
 
  using pointer = ValueType *;
 
  using const_pointer = const ValueType *;
 
  using reference = ValueType &;
 
  using const_reference = const ValueType &;
 
  using iterator = ValueType *;
 
  using const_iterator = const ValueType *;
 
  using reverse_iterator = std::reverse_iterator<iterator>;
 
  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
  using SizeType = unsigned int;
 
public:
  FixedArray() = default;
  FixedArray(const FixedArray &) = default;
  FixedArray &
  operator=(const FixedArray &) = default;
  FixedArray(FixedArray &&) = default;
  FixedArray &
  operator=(FixedArray &&) = default;
  ~FixedArray() = default;
 
  FixedArray(const ValueType r[VLength]);
  FixedArray(const ValueType &);
 
  explicit FixedArray(const std::array<ValueType, VLength> & stdArray)
  {
    std::copy_n(stdArray.cbegin(), VLength, m_InternalArray);
  }
 
  template <typename TFixedArrayValueType>
  FixedArray(const FixedArray<TFixedArrayValueType, VLength> & r)
  {
    auto input = r.cbegin();
 
    for (auto & element : m_InternalArray)
    {
      element = static_cast<TValue>(*input++);
    }
  }
 
  template <typename TScalarValue>
  FixedArray(const TScalarValue * r)
  {
    std::copy_n(r, VLength, m_InternalArray);
  }
 
  template <typename TFixedArrayValueType>
  FixedArray &
  operator=(const FixedArray<TFixedArrayValueType, VLength> & r)
  {
    auto input = r.cbegin();
 
    for (auto & element : m_InternalArray)
    {
      element = static_cast<TValue>(*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]; }
// false positive warnings with GCC
#if defined(__GNUC__)
#  if (__GNUC__ == 4) && (__GNUC_MINOR__ == 9) || (__GNUC__ >= 7)
#    pragma GCC diagnostic push
#    pragma GCC diagnostic ignored "-Warray-bounds"
#  endif
#endif
  reference       operator[](unsigned int index) { return m_InternalArray[index]; }
  const_reference operator[](unsigned int index) const { return m_InternalArray[index]; }
#if defined(__GNUC__)
#  if (__GNUC__ == 4) && (__GNUC_MINOR__ == 9) || (__GNUC__ >= 7)
#    pragma GCC diagnostic pop
#  endif
#endif
  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 int index, const_reference value)
  {
    m_InternalArray[index] = value;
  }
  const_reference
  GetElement(unsigned int index) const
  {
    return m_InternalArray[index];
  }
 
  ValueType *
  GetDataPointer()
  {
    return m_InternalArray;
  }
 
  const ValueType *
  GetDataPointer() const
  {
    return m_InternalArray;
  }
 
  ValueType *
  data()
  {
    return m_InternalArray;
  }
 
  const ValueType *
  data() const
  {
    return m_InternalArray;
  }
 
  Iterator
  Begin();
 
  ConstIterator
  Begin() const;
 
  Iterator
  End();
 
  ConstIterator
  End() const;
 
  itkLegacyMacro(ReverseIterator rBegin());
 
  itkLegacyMacro(ConstReverseIterator rBegin() const);
 
  itkLegacyMacro(ReverseIterator rEnd());
 
  itkLegacyMacro(ConstReverseIterator rEnd() const);
 
  const_iterator
  cbegin() const noexcept
  {
    return m_InternalArray;
  }
 
  iterator
  begin() noexcept
  {
    return m_InternalArray;
  }
 
  const_iterator
  begin() const noexcept
  {
    return this->cbegin();
  }
 
  const_iterator
  cend() const noexcept
  {
    return m_InternalArray + VLength;
  }
 
  iterator
  end() noexcept
  {
    return m_InternalArray + VLength;
  }
 
  const_iterator
  end() const noexcept
  {
    return this->cend();
  }
 
  reverse_iterator
  rbegin()
  {
    return reverse_iterator{ this->end() };
  }
 
  const_reverse_iterator
  crbegin() const
  {
    return const_reverse_iterator{ this->cend() };
  }
 
  const_reverse_iterator
  rbegin() const
  {
    return this->crbegin();
  }
 
  reverse_iterator
  rend()
  {
    return reverse_iterator{ this->begin() };
  }
 
  const_reverse_iterator
  crend() const
  {
    return const_reverse_iterator{ this->cbegin() };
  }
 
  const_reverse_iterator
  rend() const
  {
    return this->crend();
  }
 
  SizeType
  Size() const;
 
  constexpr SizeType
  size() const
  {
    return VLength;
  }
 
  void
  Fill(const ValueType &);
 
  void
  swap(FixedArray & other)
  {
    std::swap(m_InternalArray, other.m_InternalArray);
  }
 
private:
  CArray m_InternalArray;
 
public:
  static FixedArray
  Filled(const ValueType &);
};
 
template <typename TValue, unsigned int VLength>
std::ostream &
operator<<(std::ostream & os, const FixedArray<TValue, VLength> & arr);
 
 
template <typename TValue, unsigned int VLength>
inline void
swap(FixedArray<TValue, VLength> & a, FixedArray<TValue, VLength> & b)
{
  a.swap(b);
}
 
} // namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkFixedArray.hxx"
#endif
 
#include "itkNumericTraitsFixedArrayPixel.h"
 
#endif