itkNeighborhoodAllocator.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 itkNeighborhoodAllocator_h
#define itkNeighborhoodAllocator_h
#include <algorithm>
#include <iostream>
#include "itkMacro.h"

namespace itk
{
template< typename TPixel >
class NeighborhoodAllocator
{
public:
  using Self = NeighborhoodAllocator;

  using iterator = TPixel *;
  using const_iterator = const TPixel *;

  NeighborhoodAllocator(): m_Data(nullptr)  {}

  ~NeighborhoodAllocator()
  { this->Deallocate(); }

  void Allocate(unsigned int n)
  {
    m_Data = new TPixel[n];
    m_ElementCount = n;
  }

  void Deallocate()
  {
    delete[] m_Data;
    m_ElementCount = 0;
  }

  NeighborhoodAllocator(const Self & other):
    m_ElementCount(other.m_ElementCount),
    m_Data(new TPixel[other.m_ElementCount])
  {
    std::copy(other.m_Data, other.m_Data + m_ElementCount, m_Data);
  }


  NeighborhoodAllocator(Self&& other) ITK_NOEXCEPT
    :
  m_ElementCount{ other.m_ElementCount },
  m_Data{ other.m_Data }
  {
    other.m_ElementCount = 0;
    other.m_Data = nullptr;
  }


  Self & operator=(const Self & other)
  {
    if(this != &other)
      {
      this->set_size(other.m_ElementCount);
      std::copy(other.m_Data, other.m_Data + m_ElementCount, m_Data);
    }
    return *this;
  }


  Self& operator=(Self&& other) ITK_NOEXCEPT
  {
    if (this != &other)
    {
      this->Deallocate();
      m_ElementCount = other.m_ElementCount;
      m_Data = other.m_Data;
      other.m_ElementCount = 0;
      other.m_Data = nullptr;
    }
    return *this;
  }


  iterator begin()
  { return m_Data; }
  const_iterator begin() const
  { return m_Data; }
  iterator end()
  { return ( m_Data + m_ElementCount ); }
  const_iterator end() const
  { return ( m_Data + m_ElementCount ); }
  unsigned int size() const
  { return m_ElementCount; }

  const TPixel & operator[](unsigned int i) const
  { return m_Data[i]; }
  TPixel & operator[](unsigned int i)
  { return m_Data[i]; }

  void set_size(unsigned int n)
  {
    if (n != m_ElementCount)
      {
      if ( m_Data )
        {
        this->Deallocate();
        }
      this->Allocate(n);
      }
  }

protected:
  unsigned int m_ElementCount{0};
  TPixel *     m_Data;
};

template< typename TPixel >
inline std::ostream & operator<<(
  std::ostream & o, const NeighborhoodAllocator< TPixel >
  & a)
{
  o << "NeighborhoodAllocator { this = " << &a << ", begin = "
  << static_cast< const void * >( a.begin() )
  << ", size=" << a.size()
  << " }";
  return o;
}


// Equality operator.
template< typename TPixel >
inline bool operator==(
  const NeighborhoodAllocator< TPixel >& lhs,
  const NeighborhoodAllocator< TPixel >& rhs)
{
  const unsigned int size = lhs.size();
  return (size == rhs.size()) &&
    ((size == 0) || std::equal(lhs.begin(), lhs.end(), rhs.begin()));
}

// Inequality operator.
template< typename TPixel >
inline bool operator!=(
  const NeighborhoodAllocator< TPixel >& lhs,
  const NeighborhoodAllocator< TPixel >& rhs)
{
  return ! (lhs == rhs);
}
} // end namespace itk
#endif