otbObjectList.h

Go to the documentation of this file.

/*
 * Copyright (C) 2005-2020 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