otbObjectList.h

Go to the documentation of this file.

/*=========================================================================

  Program:   ORFEO Toolbox
  Language:  C++
  Date:      $Date$
  Version:   $Revision$


  Copyright (c) Centre National d'Etudes Spatiales. All rights reserved.
  See OTBCopyright.txt for details.


     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __otbObjectList_h
#define __otbObjectList_h

#include <vector>
#include "itkDataObject.h"
#include "itkObjectFactory.h"

namespace otb
{
template <class TObject>
class ITK_EXPORT ObjectList : public itk::DataObject
{
public:
  typedef ObjectList                    Self;
  typedef itk::DataObject               Superclass;
  typedef itk::SmartPointer<Self>       Pointer;
  typedef itk::SmartPointer<const Self> ConstPointer;

  itkTypeMacro(ObjectList, DataObject);

  itkNewMacro(Self);

  typedef TObject                        ObjectType;
  typedef itk::SmartPointer<ObjectType>  ObjectPointerType;
  typedef std::vector<ObjectPointerType> InternalContainerType;

  void Reserve(unsigned int size);
  unsigned int Capacity(void) const;
  unsigned int Size(void) const;
  void Resize(unsigned int size);
  void PushBack(ObjectType* element);
  void PopBack(void);
  void SetNthElement(unsigned int index, ObjectPointerType element);
  void SetNthElement(unsigned int index, const ObjectType * element);
  ObjectPointerType GetNthElement(unsigned int index) const;
  ObjectPointerType Front(void);
  ObjectPointerType Back(void);
  void Erase(unsigned int index);
  void Clear(void);

  class ConstIterator;
  class ReverseIterator;
  class ReverseConstIterator;
  class Iterator;
  friend class Iterator;
  friend class ConstIterator;
  friend class ReverseIterator;
  friend class ReverseConstIterator;

  Iterator Insert(Iterator position, ObjectPointerType element);
  ReverseIterator Insert(ReverseIterator position, ObjectPointerType element);

  class ITK_EXPORT Iterator
  {
public:
    friend class ObjectList;
    friend class ConstIterator;
    typedef typename InternalContainerType::iterator InternalIteratorType;
    Iterator() {};
    Iterator(InternalIteratorType iter)
      {
      m_Iter = iter;
      };
    ObjectPointerType Get(void)
    {
      return (*m_Iter);
    }
    void Set(ObjectPointerType element)
    {
      (*m_Iter) = element;
      this->Modified();
    }
    Iterator & operator ++()
    {
      ++m_Iter;
      return *this;
    }
    Iterator & operator --()
    {
      --m_Iter;
      return *this;
    }
    Iterator operator +(int i)
    {
      Iterator lIter(m_Iter + i);
      return lIter;
    }

    Iterator operator -(int i)
    {
      Iterator lIter(m_Iter - i);
      return lIter;
    }
    bool operator !=(const Iterator& it)
    {
      return (m_Iter != it.m_Iter);
    }
    bool operator ==(const Iterator& it)
    {
      return (m_Iter == it.m_Iter);
    }
    Iterator & operator =(const Iterator& it)
    {
      m_Iter = it.m_Iter;
      return *this;
    }
    Iterator(const Iterator &it)
      {
      m_Iter = it.m_Iter;
      };

    InternalIteratorType& GetIter(void)
    {
      return (m_Iter);
    }
private:
    // Internal iterator.
    InternalIteratorType m_Iter;
  };
  class ITK_EXPORT ConstIterator
  {
public:
    friend class ObjectList;
    friend class Iterator;
    typedef typename InternalContainerType::const_iterator InternalConstIteratorType;
    ConstIterator() {};
    ConstIterator(InternalConstIteratorType iter)
      {
      m_Iter = iter;
      };
    ObjectPointerType Get(void)
    {
      return (*m_Iter);
    }
    ConstIterator & operator ++()
    {
      ++m_Iter;
      return *this;
    }
    ConstIterator & operator --()
    {
      --m_Iter;
      return *this;
    }
    bool operator !=(const ConstIterator& it)
    {
      return (m_Iter != it.m_Iter);
    }
    bool operator ==(const ConstIterator& it)
    {
      return (m_Iter == it.m_Iter);
    }
    ConstIterator & operator =(const ConstIterator& it)
    {
      m_Iter = it.m_Iter;
      return *this;
    }
    ConstIterator & operator =(const Iterator& it)
    {
      m_Iter = it.m_Iter;
      return *this;
    }
    ConstIterator(const ConstIterator &it)
      {
      m_Iter = it.m_Iter;
      };
    ConstIterator(const Iterator &it)
      {
      m_Iter = it.m_Iter;
      };

private:
    // Internal iterator.
    InternalConstIteratorType m_Iter;
  };
  class ITK_EXPORT ReverseIterator
  {
public:
    friend class ObjectList;
    friend class Iterator;

    friend class ReverseConstIterator;
    typedef typename InternalContainerType::reverse_iterator InternalReverseIteratorType;
    ReverseIterator() {};
    ReverseIterator(InternalReverseIteratorType iter)
      {
      m_Iter = iter;
      };
    ObjectPointerType Get(void)
    {
      return (*m_Iter);
    }
    void Set(ObjectPointerType element)
    {
      (*m_Iter) = element;
    }
    ReverseIterator & operator ++()
    {
      ++m_Iter;
      return *this;
    }
    ReverseIterator & operator --()
    {
      --m_Iter;
      return *this;
    }
    bool operator !=(const ReverseIterator& it)
    {
      return (m_Iter != it.m_Iter);
    }
    bool operator ==(const ReverseIterator& it)
    {
      return (m_Iter == it.m_Iter);
    }
    ReverseIterator & operator =(const ReverseIterator& it)
    {
      m_Iter = it.m_Iter;
      return *this;
    }
    ReverseIterator(const ReverseIterator &it)
      {
      m_Iter = it.m_Iter;
      };

    InternalReverseIteratorType& GetIter(void)
    {
      return (m_Iter);
    }

private:
    // Internal iterator.
    InternalReverseIteratorType m_Iter;
  };
  class ITK_EXPORT ReverseConstIterator
  {
public:
    friend class ObjectList;
    friend class Iterator;
    friend class ConstIterator;
    friend class ReverseIterator;
    typedef typename InternalContainerType::reverse_iterator InternalReverseConstIteratorType;
    ReverseConstIterator() {};
    ReverseConstIterator(InternalReverseConstIteratorType iter)
      {
      m_Iter = iter;
      };
    ObjectPointerType Get(void)
    {
      return (*m_Iter);
    }
    ReverseConstIterator & operator ++()
    {
      ++m_Iter;
      return *this;
    }
    ReverseConstIterator & operator --()
    {
      --m_Iter;
      return *this;
    }
    bool operator !=(const ReverseConstIterator& it)
    {
      return (m_Iter != it.m_Iter);
    }
    bool operator ==(const ReverseConstIterator& it)
    {
      return (m_Iter == it.m_Iter);
    }
    ReverseConstIterator & operator =(const ReverseConstIterator& it)
    {
      m_Iter = it.m_Iter;
      return *this;
    }
    ReverseConstIterator & operator =(const ReverseIterator& it)
    {
      m_Iter = it.m_Iter;
      return *this;
    }
    ReverseConstIterator(const ReverseConstIterator &it)
      {
      m_Iter = it.m_Iter;
      };
    ReverseConstIterator(const ReverseIterator &it)
      {
      m_Iter = it.m_Iter;
      };

private:
    // Internal iterator.
    InternalReverseConstIteratorType m_Iter;
  };
  Iterator Begin(void);
  ConstIterator Begin(void) const;
  ReverseIterator ReverseBegin(void);
  ReverseConstIterator ReverseBegin(void) const;
  Iterator End(void);
  ConstIterator End(void) const;
  ReverseIterator ReverseEnd(void);
  ReverseConstIterator ReverseEnd(void) const;
  void Erase(Iterator begin, Iterator end);

  void Erase(Iterator loc);

protected:
  ObjectList();
  ~ObjectList() {}
  void PrintSelf(std::ostream& os, itk::Indent indent) const;

private:
  ObjectList(const Self &); //purposely not implemented
  void operator =(const Self&); //purposely not implemented
  InternalContainerType m_InternalContainer;
};
} // end namespace otb

#ifndef OTB_MANUAL_INSTANTIATION
#include "otbObjectList.txx"
#endif

#endif