wrap_pointer_iterator.hpp

Go to the documentation of this file.

#pragma once
#include "../../../icomparable.hpp"
#include "../../../iequatable.hpp"
#include "../../../ptrdiff.hpp"
#include "../../../size.hpp"
#include <iterator>

namespace xtd {
  namespace collections {
    namespace generic {
      namespace helpers {
        template<class value_t, class iterator_tag_t = std::bidirectional_iterator_tag>
        class wrap_pointer_iterator : public xtd::icomparable<wrap_pointer_iterator<value_t, iterator_tag_t>>, public xtd::iequatable<wrap_pointer_iterator<value_t, iterator_tag_t >> {
        public:
          
          using value_type = value_t;
          using iterator_category = iterator_tag_t;
          using iterator_concept  = iterator_tag_t;
          using difference_type = xtd::ptrdiff;
          using pointer = value_type*;
          using const_pointer = const value_type*;
          using reference = value_type&;
          using const_reference = const value_type&;
          
          
          wrap_pointer_iterator() = default;
          explicit wrap_pointer_iterator(value_t pointer) noexcept : data_ {pointer} {}
          
          wrap_pointer_iterator(const wrap_pointer_iterator& value) noexcept = default;
          wrap_pointer_iterator& operator =(const wrap_pointer_iterator& value) noexcept = default;
          wrap_pointer_iterator(wrap_pointer_iterator&& value) noexcept = default;
          wrap_pointer_iterator& operator =(wrap_pointer_iterator&& value) noexcept = default;
          
          
          auto data() const noexcept -> const value_t& {return data_;}
          auto data() noexcept -> value_t& {return data_;}
          
          
          auto compare_to(const wrap_pointer_iterator& rhs) const noexcept -> int32 override {return data_ < rhs.data_ ? -1 : data_ > rhs.data_ ? 1 : 0;}
          auto equals(const wrap_pointer_iterator& rhs) const noexcept -> bool override {return data_ == rhs.data_;}
          
          
          auto operator *() const noexcept -> const std::remove_pointer_t<value_t>& {return *data_;}
          auto operator *() noexcept -> std::remove_pointer_t<value_t>& {return *data_;}
          auto operator ->() const noexcept -> const value_t& {return data_;}
          auto operator ->() noexcept -> value_t& {return data_;}
          
          auto operator ++() const noexcept -> wrap_pointer_iterator& {++data_; return *const_cast<wrap_pointer_iterator*>(this);}
          auto operator ++(int) const noexcept -> wrap_pointer_iterator {auto current = *this; operator ++(); return current;}
          
          auto operator --() const noexcept -> wrap_pointer_iterator& {--data_; return *const_cast<wrap_pointer_iterator*>(this);}
          auto operator --(int) const noexcept -> wrap_pointer_iterator {auto current = *this; operator --(); return current;}
          
          auto operator +(xtd::size value) const noexcept -> wrap_pointer_iterator {return wrap_pointer_iterator {data_ + value};}
          auto operator +=(xtd::size value) noexcept -> wrap_pointer_iterator& {*this = *this + value; return *this;}
          auto operator -(wrap_pointer_iterator value) const noexcept -> xtd::ptrdiff {return data_ - value.data_;}
          
        private:
          mutable value_t data_ = nullptr;
        };
      }
    }
  }
}