Iterator.hh

Go to the documentation of this file.

#ifndef __DIADES__UTILS__ITERATORS__HH
#define __DIADES__UTILS__ITERATORS__HH

#include<diades/utils/Assertion.hh>
#include<diades/utils/Exceptions.hh>

#include "Pointer.hh"


namespace Diades
{
   namespace Utils
   {

      template<typename Mapper>
      class RangeMapperIterator
      {
      public:
         using MapStructure = typename Mapper::MapStructure;
         using Iterator = typename Mapper::Iterator;
         using Data = typename Mapper::Data;

      private:
         const MapStructure * _mapStructure;
         Iterator _it;
      public:
         typedef const Data & reference;
         using iterator_category = std::forward_iterator_tag;

         explicit
         RangeMapperIterator(const MapStructure & m, Iterator it) : _mapStructure(&m), _it(it)
         {
         }

         RangeMapperIterator(const RangeMapperIterator & it) : _mapStructure(it._mapStructure), _it(it._it)
         {
         }

         RangeMapperIterator & operator=(const RangeMapperIterator & it)
         {
            if(this != &it)
            {
               _mapStructure = it._mapStructure;
               _it = it._it;
            }
            return *this;
         }

         RangeMapperIterator & operator++()
         {
            ++_it;
            return *this;
         }

         RangeMapperIterator operator++(int)
         {
            auto tmp = *this;
            ++ * this;
            return tmp;
         }

         reference operator*() const
         {
            return Mapper()(*_mapStructure, _it);
         }

         bool operator==(const RangeMapperIterator & it) const
         {
            return(_mapStructure == it._mapStructure) && (_it == it._it);
         }

         bool operator!=(const RangeMapperIterator & it) const
         {
            return !(*this == it);
         }
      };



      template<typename T, template <typename ...> class Container>
      class SharedPointerIterator : public Container<std::shared_ptr<T>>::iterator
      {
         public:
         typedef T& reference;
         typedef typename Ptr<T>::P pointer;
         
         static string typeName()
         {
            return "Automata::SharedPointerIterator";
         }
         using Exception = Diades::Utils::Exception<SharedPointerIterator>;

         public:
         using Iterator = typename Container<std::shared_ptr < T>>::iterator;

         SharedPointerIterator() : Iterator()
         {
         };

         SharedPointerIterator(Iterator it) : Iterator(it)
         {
         };

         pointer operator->()
         {
            always_require(Exception, Iterator::operator*(),
                           "operator->(): attempt to access the content of a null shared pointer.");
            return(Iterator::operator*()).get();
         }

         reference operator*()
         {
            always_require(Exception, Iterator::operator*(),
                           "operator*(): attempt to access the content of a null shared pointer.");
            return *(Iterator::operator*());
         }
      };



      template<typename T, template <typename ...> class Container>
      class SharedPointerConstIterator : public Container<std::shared_ptr<T>>::const_iterator
      {
         public:
         typedef const T& reference;
         typedef typename Ptr<T>::ConstP pointer;

         static string typeName()
         {
            return "Automata::SharedPointerIterator";
         }
         using Exception = Diades::Utils::Exception<SharedPointerConstIterator>;

         public:
         using Iterator = typename Container<std::shared_ptr < T>>::const_iterator;

         SharedPointerConstIterator() : Iterator()
         {
         };

         SharedPointerConstIterator(Iterator it) : Iterator(it)
         {
         };

         pointer operator->() const
         {
            always_require(Exception, Iterator::operator*(),
                           "operator->(): attempt to access the content of a null shared pointer.");
            return(Iterator::operator*()).get();
         }

         reference operator*() const
         {
            always_require(Exception, Iterator::operator*(),
                           "operator*(): attempt to access the content of a null shared pointer.");
            return *(Iterator::operator*());
         }
      };

      template<typename T, template <typename ...> class Container>
      class RawPointerIterator : public Container<typename Ptr<T>::P>::iterator
      {
      public:
         typedef T& reference;
         typedef typename Ptr<T>::P pointer;
         
         static string
         typeName()
         {
            return "Automata::SharedPointerIterator";
         }
         using Exception = Diades::Utils::Exception<RawPointerIterator>;

      public:
         using Iterator = typename Container<pointer>::iterator;

         RawPointerIterator() : Iterator()
         {
         };

         RawPointerIterator(Iterator it) : Iterator(it)
         {
         };

         pointer operator->()
         {
            always_require(Exception, Iterator::operator*(),
                           "operator->(): attempt to access the content of a null shared pointer.");
            return(Iterator::operator*());
         }

         reference operator*()
         {
            always_require(Exception, Iterator::operator*(),
                           "operator*(): attempt to access the content of a null shared pointer.");
            return *(Iterator::operator*());
         }
      };

      template<typename T, template <typename ...> class Container>
      class ConstRawPointerConstIterator : public Container<typename Ptr<T>::ConstP>::const_iterator
      {
      public:
         typedef const T& reference;
         typedef typename Ptr<T>::ConstP pointer;

         static string
         typeName()
         {
            return "Diades::Utils::ConstRawPointerConstIterator";
         }
         using Exception = Diades::Utils::Exception<ConstRawPointerConstIterator>;

      public:
         using Iterator = typename Container<pointer>::const_iterator;

         ConstRawPointerConstIterator() : Iterator()
         {
         };

         ConstRawPointerConstIterator(Iterator it) : Iterator(it)
         {
         };

         pointer operator->()
         {
            always_require(Exception, Iterator::operator*(),
                           "operator->(): attempt to access the content of a null shared pointer.");
            return(Iterator::operator*());
         }

         reference operator*()
         {
            always_require(Exception, Iterator::operator*(),
                           "operator*(): attempt to access the content of a null shared pointer.");
            return *(Iterator::operator*());
         }
      };




   }
}


#endif /*  __DIADES__UTILS__ITERATORS__HH */