otbObjectList.h

Go to the documentation of this file.

/*
 * Copyright (C) 2005-2022 Centre National d'Etudes Spatiales (CNES)
 *
 * This file is part of Orfeo Toolbox
 *
 *     https://www.orfeo-toolbox.org/
 *
 * 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
 *
 * 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 otbObjectList_h
#define otbObjectList_h
 
#include <vector>
#include "itkDataObject.h"
#include "otbDataObjectListInterface.h"
#include "itkObjectFactory.h"
 
namespace otb
{
template <class TObject>
class ITK_EXPORT ObjectList : public itk::DataObject, public DataObjectListInterface
{
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;
  typedef typename InternalContainerType::size_type InternalContainerSizeType;
 
  void Reserve(InternalContainerSizeType size);
 
  InternalContainerSizeType Capacity(void) const;
 
  InternalContainerSizeType Size(void) const override;
 
  void Resize(InternalContainerSizeType 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;
 
  Superclass* GetNthDataObject(unsigned int index) const override;
 
  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;
    }
 
    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;
    }
 
    Iterator operator+=(int i)
    {
      return m_Iter + i;
    }
 
    Iterator operator-=(int i)
    {
      return m_Iter - i;
    }
 
    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::const_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() override
  {
  }
 
  void PrintSelf(std::ostream& os, itk::Indent indent) const override;
 
private:
  ObjectList(const Self&) = delete;
  void operator=(const Self&) = delete;
  InternalContainerType m_InternalContainer;
};
} // end namespace otb
 
#ifndef OTB_MANUAL_INSTANTIATION
#include "otbObjectList.hxx"
#endif
 
#endif