itkMapContainer.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 itkMapContainer_h
#define itkMapContainer_h

#include "itkObject.h"
#include "itkObjectFactory.h"

#include <map>

namespace itk
{
template< typename TElementIdentifier, typename TElement >
class MapContainer:
  public Object,
  private std::map< TElementIdentifier, TElement >
{
public:
  typedef MapContainer               Self;
  typedef Object                     Superclass;
  typedef SmartPointer< Self >       Pointer;
  typedef SmartPointer< const Self > ConstPointer;

  itkTypeMacro(MapContainer, Object);

  typedef TElementIdentifier ElementIdentifier;
  typedef TElement           Element;

private:
  MapContainer(const Self &) ITK_DELETE_FUNCTION;
  void operator=(const Self &) ITK_DELETE_FUNCTION;

  typedef std::map< ElementIdentifier, Element > MapType;
  typedef typename MapType::iterator             MapIterator;
  typedef typename MapType::const_iterator       MapConstIterator;
  typedef typename MapType::key_compare          MapKeyCompareType;

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);

  typedef MapType STLContainerType;

  STLContainerType & CastToSTLContainer()
  { return dynamic_cast< STLContainerType & >( *this ); }

  const STLContainerType & CastToSTLConstContainer() const
  {
    return dynamic_cast< const STLContainerType & >( *this );
  }

  using STLContainerType::begin;
  using STLContainerType::end;
  using STLContainerType::rbegin;
  using STLContainerType::rend;

  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:
    typedef typename MapIterator::iterator_category iterator_category;
    typedef typename MapIterator::value_type        value_type;
    typedef typename MapIterator::difference_type   difference_type;
    typedef typename MapIterator::pointer           pointer;
    typedef typename MapIterator::reference         reference;

    Iterator() {}
    Iterator(const Iterator & i):m_Iter(i.m_Iter) {}
    Iterator(const MapIterator & i):m_Iter(i) {}
    Iterator & operator=(const Iterator & r ) { m_Iter = r.m_Iter; return *this; }

    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; }
    bool operator!=(const Iterator & r) const { return m_Iter != r.m_Iter; }
    bool operator==(const ConstIterator & r) const { return m_Iter == r.m_Iter; }
    bool operator!=(const ConstIterator & r) const { return m_Iter != r.m_Iter; }

    ElementIdentifier Index(void) const { return m_Iter->first; }

    Element & Value(void) { return m_Iter->second; }

private:
    MapIterator m_Iter;
    friend class ConstIterator;
  };

  class ConstIterator
  {
public:
    typedef typename MapConstIterator::iterator_category iterator_category;
    typedef typename MapConstIterator::value_type        value_type;
    typedef typename MapConstIterator::difference_type   difference_type;
    typedef typename MapConstIterator::pointer           pointer;
    typedef typename MapConstIterator::reference         reference;

    ConstIterator() {}
    ConstIterator(const MapConstIterator & ci):m_Iter(ci) {}
    ConstIterator(const Iterator & r) : m_Iter( r.m_Iter ) {}
    ConstIterator & operator=(const ConstIterator & r ) { m_Iter = r.m_Iter; return *this; }

    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; }
    bool operator!=(const Iterator & r) const { return m_Iter != r.m_Iter; }
    bool operator==(const ConstIterator & r) const { return m_Iter == r.m_Iter; }
    bool operator!=(const ConstIterator & r) const { return m_Iter != r.m_Iter; }

    ElementIdentifier Index(void) const { return m_Iter->first; }

    const Element & Value(void) 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