itkMapContainer.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 itkMapContainer_h
#define itkMapContainer_h
 
#include "itkObject.h"
#include "itkObjectFactory.h"
 
#include <map>
 
namespace itk
{
template <typename TElementIdentifier, typename TElement>
class ITK_TEMPLATE_EXPORT MapContainer
  : public Object
  , private std::map<TElementIdentifier, TElement>
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(MapContainer);

  using Self = MapContainer;
  using Superclass = Object;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;

  itkOverrideGetNameOfClassMacro(MapContainer);

  using ElementIdentifier = TElementIdentifier;
  using Element = TElement;
 
private:
  using MapType = std::map<ElementIdentifier, Element>;
  using MapIterator = typename MapType::iterator;
  using MapConstIterator = typename MapType::const_iterator;
  using MapKeyCompareType = typename MapType::key_compare;
 
public:
  MapContainer()
    : MapType()
  {}
  MapContainer(const MapKeyCompareType & comp)
    : MapType(comp)
  {}
  //  MapContainer(const Self& r):MapType(r) {}
  template <typename TInputIterator>
  MapContainer(TInputIterator first, TInputIterator last)
    : MapType(first, last)
  {}
  template <typename TInputIterator>
  MapContainer(TInputIterator first, TInputIterator last, const MapKeyCompareType & comp)
    : MapType(first, last, comp)
  {}

  itkNewMacro(Self);

  using STLContainerType = MapType;

  STLContainerType &
  CastToSTLContainer() noexcept
  {
    return *this;
  }

  const STLContainerType &
  CastToSTLConstContainer() const noexcept
  {
    return *this;
  }
 
  using STLContainerType::begin;
  using STLContainerType::cbegin;
  using STLContainerType::end;
  using STLContainerType::cend;
  using STLContainerType::rbegin;
  using STLContainerType::crbegin;
  using STLContainerType::rend;
  using STLContainerType::crend;
 
  using STLContainerType::empty;
  using STLContainerType::size;
  using STLContainerType::max_size;
 
  using STLContainerType::operator[];
 
  using STLContainerType::insert;
  using STLContainerType::erase;
  using STLContainerType::swap;
  using STLContainerType::clear;
 
  using STLContainerType::key_comp;
  using STLContainerType::value_comp;
 
  using STLContainerType::find;
  using STLContainerType::count;
  using STLContainerType::lower_bound;
  using STLContainerType::upper_bound;
  using STLContainerType::equal_range;
 
  using STLContainerType::get_allocator;
 
  using typename STLContainerType::key_type;
  using typename STLContainerType::mapped_type;
  using typename STLContainerType::value_type;
  using typename STLContainerType::key_compare;
  using typename STLContainerType::value_compare;
  using typename STLContainerType::allocator_type;
  using typename STLContainerType::reference;
  using typename STLContainerType::const_reference;
  using typename STLContainerType::iterator;
  using typename STLContainerType::const_iterator;
  using typename STLContainerType::size_type;
  using typename STLContainerType::difference_type;
  using typename STLContainerType::pointer;
  using typename STLContainerType::const_pointer;
  using typename STLContainerType::reverse_iterator;
  using typename STLContainerType::const_reverse_iterator;

  class Iterator;
  class ConstIterator;
  friend class Iterator;
  friend class ConstIterator;

  class Iterator
  {
  public:
    using iterator_category = typename MapIterator::iterator_category;
    using value_type = typename MapIterator::value_type;
    using difference_type = typename MapIterator::difference_type;
    using pointer = typename MapIterator::pointer;
    using reference = typename MapIterator::reference;
 
    Iterator() = default;
    Iterator(const MapIterator & i)
      : m_Iter(i)
    {}
 
    Iterator &
    operator*()
    {
      return *this;
    }
    Iterator *
    operator->()
    {
      return this;
    }
    Iterator &
    operator++()
    {
      ++m_Iter;
      return *this;
    }
    Iterator
    operator++(int)
    {
      Iterator temp(*this);
      ++m_Iter;
      return temp;
    }
    Iterator &
    operator--()
    {
      --m_Iter;
      return *this;
    }
    Iterator
    operator--(int)
    {
      Iterator temp(*this);
      --m_Iter;
      return temp;
    }
 
    bool
    operator==(const Iterator & r) const
    {
      return m_Iter == r.m_Iter;
    }
 
    ITK_UNEQUAL_OPERATOR_MEMBER_FUNCTION(Iterator);
 
    bool
    operator==(const ConstIterator & r) const
    {
      return m_Iter == r.m_Iter;
    }
 
    ITK_UNEQUAL_OPERATOR_MEMBER_FUNCTION(ConstIterator);

    [[nodiscard]] ElementIdentifier
    Index() const
    {
      return m_Iter->first;
    }

    Element &
    Value()
    {
      return m_Iter->second;
    }
 
  private:
    MapIterator m_Iter;
    friend class ConstIterator;
  };

  class ConstIterator
  {
  public:
    using iterator_category = typename MapConstIterator::iterator_category;
    using value_type = typename MapConstIterator::value_type;
    using difference_type = typename MapConstIterator::difference_type;
    using pointer = typename MapConstIterator::pointer;
    using reference = typename MapConstIterator::reference;
 
    ConstIterator() = default;
    ConstIterator(const MapConstIterator & ci)
      : m_Iter(ci)
    {}
    ConstIterator(const Iterator & r)
      : m_Iter(r.m_Iter)
    {}
 
    ConstIterator &
    operator*()
    {
      return *this;
    }
    ConstIterator *
    operator->()
    {
      return this;
    }
    ConstIterator &
    operator++()
    {
      ++m_Iter;
      return *this;
    }
    ConstIterator
    operator++(int)
    {
      ConstIterator temp(*this);
      ++m_Iter;
      return temp;
    }
    ConstIterator &
    operator--()
    {
      --m_Iter;
      return *this;
    }
    ConstIterator
    operator--(int)
    {
      ConstIterator temp(*this);
      --m_Iter;
      return temp;
    }
 
    bool
    operator==(const Iterator & r) const
    {
      return m_Iter == r.m_Iter;
    }
 
    ITK_UNEQUAL_OPERATOR_MEMBER_FUNCTION(Iterator);
 
    bool
    operator==(const ConstIterator & r) const
    {
      return m_Iter == r.m_Iter;
    }
 
    ITK_UNEQUAL_OPERATOR_MEMBER_FUNCTION(ConstIterator);

    [[nodiscard]] ElementIdentifier
    Index() const
    {
      return m_Iter->first;
    }

    [[nodiscard]] const Element &
    Value() const
    {
      return m_Iter->second;
    }
 
  private:
    MapConstIterator m_Iter;
    friend class Iterator;
  };
 
  /* Declare the public interface routines. */

  Element & ElementAt(ElementIdentifier);

  const Element & ElementAt(ElementIdentifier) const;

  Element & CreateElementAt(ElementIdentifier);

  Element GetElement(ElementIdentifier) const;

  void SetElement(ElementIdentifier, Element);

  void InsertElement(ElementIdentifier, Element);

  bool IndexExists(ElementIdentifier) const;

  bool
  GetElementIfIndexExists(ElementIdentifier, Element *) const;

  void CreateIndex(ElementIdentifier);

  void DeleteIndex(ElementIdentifier);

  ConstIterator
  Begin() const;

  ConstIterator
  End() const;

  Iterator
  Begin();

  Iterator
  End();

  ElementIdentifier
  Size() const;

  void Reserve(ElementIdentifier);

  void
  Squeeze()
  {}

  void
  Initialize();
};
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkMapContainer.hxx"
#endif
 
#endif