itkNeighborhoodAllocator.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
 *
 *         https://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 "itkMakeUniqueForOverwrite.h"
#include <algorithm>
#include <iostream>
#include <memory>
#include "itkMacro.h"
 
namespace itk
{
template <typename TPixel>
class NeighborhoodAllocator
{
public:
  using Self = NeighborhoodAllocator;
 
  using iterator = TPixel *;
  using const_iterator = const TPixel *;
 
  NeighborhoodAllocator() = default;
 
  ~NeighborhoodAllocator() = default;
 
  void
  Allocate(unsigned int n)
  {
    m_Data = make_unique_for_overwrite<TPixel[]>(n);
    m_ElementCount = n;
  }
  void
  Deallocate()
  {
    m_Data.reset();
    m_ElementCount = 0;
  }
  NeighborhoodAllocator(const Self & other)
    : m_ElementCount(other.m_ElementCount)
    , m_Data(make_unique_for_overwrite<TPixel[]>(other.m_ElementCount))
  {
    std::copy_n(other.m_Data.get(), m_ElementCount, m_Data.get());
  }
 
 
  NeighborhoodAllocator(Self && other) noexcept
    : m_ElementCount{ other.m_ElementCount }
    , m_Data{ std::move(other.m_Data) }
  {
    other.m_ElementCount = 0;
  }
  Self &
  operator=(const Self & other)
  {
    if (this != &other)
    {
      this->set_size(other.m_ElementCount);
      std::copy_n(other.m_Data.get(), m_ElementCount, m_Data.get());
    }
    return *this;
  }
  Self &
  operator=(Self && other) noexcept
  {
    if (this != &other)
    {
      m_ElementCount = other.m_ElementCount;
      m_Data = std::move(other.m_Data);
      other.m_ElementCount = 0;
    }
    return *this;
  }
  iterator
  begin()
  {
    return m_Data.get();
  }
  const_iterator
  begin() const
  {
    return m_Data.get();
  }
  iterator
  end()
  {
    return (m_Data.get() + m_ElementCount);
  }
  const_iterator
  end() const
  {
    return (m_Data.get() + 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)
    {
      *this = NeighborhoodAllocator();
      m_Data = make_unique_for_overwrite<TPixel[]>(n);
      m_ElementCount = n;
    }
  }
  TPixel *
  data() noexcept
  {
    return m_Data.get();
  }
 
  const TPixel *
  data() const noexcept
  {
    return m_Data.get();
  }
 
private:
  unsigned int              m_ElementCount{ 0 };
  std::unique_ptr<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