dev_iterators.h

Go to the documentation of this file.

#ifndef __utl_dev_dev_iterators_h__
#define __utl_dev_dev_iterators_h__

#include <utl/core/impl.h>
#include <utl/meta/meta.h>

namespace utl {


   template <typename _Cat, typename _Tp, typename _Diff =ptrdiff_t>
   struct dev_iterator_traits {
      using iterator_category = _Cat;
      using value_type        = _Tp;
      using difference_type   = _Diff;
      using pointer           = _Tp*;
      using reference         = _Tp&;
   };

   struct output_iterator_tag {};
   struct input_iterator_tag {};
   struct forward_iterator_tag       : input_iterator_tag {};
   struct bidirectional_iterator_tag : forward_iterator_tag {};
   struct random_access_iterator_tag : bidirectional_iterator_tag {};
   struct contiguous_iterator_tag    : random_access_iterator_tag {};



   /*
    * ================ Output device Iterator =================
    */

   template <typename cont_t, typename data_t>
   class ostreamdev_it {
      using iterator_t = ostreamdev_it <cont_t, data_t>; 
   public:
      using type       = iterator_t;                     
   public:
      using iterator_category = typename dev_iterator_traits <std::output_iterator_tag, data_t, void>::iterator_category;
      using value_type        = typename dev_iterator_traits <std::output_iterator_tag, data_t, void>::value_type;
      using difference_type   = typename dev_iterator_traits <std::output_iterator_tag, data_t, void>::difference_type;
      using pointer           = typename dev_iterator_traits <std::output_iterator_tag, data_t, void>::pointer;
      using reference         = typename dev_iterator_traits <std::output_iterator_tag, data_t, void>::reference;

   private:
      cont_t*  owner_ {nullptr}; 
   public:
      ostreamdev_it (cont_t* owner =nullptr) noexcept
         : owner_ {owner} { }
      ostreamdev_it (const iterator_t& it) noexcept
         : owner_ {const_cast<cont_t*>(it.owner_)} { }
      iterator_t& operator= (const iterator_t& it) noexcept {
         owner_ = const_cast<cont_t*>(it.owner_);
         return *this;
      }

   public:
      iterator_t& operator* () noexcept { return *this; }
      iterator_t& operator= (const value_type& value) {
         if (owner_ != nullptr)
            owner_->put (value);
         return *this;
      }
      iterator_t& operator++ () noexcept { return *this; }
      iterator_t& operator++ (int) noexcept { return *this; }
   };

   template <typename cont_t, typename data_t>
   class istreamdev_it {
      using iterator_t = istreamdev_it <cont_t, data_t>; 
   public:
      using type       = iterator_t;                     
   public:
      using iterator_category = typename dev_iterator_traits <std::output_iterator_tag, data_t, void>::iterator_category;
      using value_type        = typename dev_iterator_traits <std::output_iterator_tag, data_t, void>::value_type;
      using difference_type   = typename dev_iterator_traits <std::output_iterator_tag, data_t, void>::difference_type;
      using pointer           = typename dev_iterator_traits <std::output_iterator_tag, data_t, void>::pointer;
      using reference         = typename dev_iterator_traits <std::output_iterator_tag, data_t, void>::reference;
      enum Cursor {
         init = 0,
         valid = 1,
         eos = 2
      };
   private:
      cont_t*    owner_ {nullptr};  
      value_type value_ {};
      Cursor     cursor_ {init};

   public:
      istreamdev_it (cont_t* owner =nullptr, Cursor cursor =eos) noexcept :
         owner_ {owner},
         value_ {},
         cursor_{cursor} { }
      istreamdev_it (const iterator_t& it) noexcept :
         owner_ {const_cast<cont_t*>(it.owner_)},
         value_ {it.value_},
         cursor_ {it.cursor_} { }
      iterator_t& operator= (const iterator_t& it) noexcept {
         owner_ = const_cast<cont_t*>(it.owner_);
         value_ = it.value_;
         cursor_ = it.cursor_;
         return *this;
      }

   public:
      value_type& operator* () noexcept {
         if (cursor_ == init)
            ++*this;
         return value_;
      }
      value_type* operator->() noexcept {
         if (cursor_ == init)
            ++*this;
         return &value_;
      }
      iterator_t& operator++ () noexcept {
         _get(value_);
         return *this;
      }
      iterator_t operator++ (int) noexcept {
         iterator_t r = *this;
         _get(value_);
         return r;
      }

      const cont_t* owner () const noexcept { return owner_; }
      const value_type& value () const noexcept { return value_; }
      const Cursor cursor () const noexcept { return cursor_; }

   private:
      void _get(value_type& v) {
         owner_->get(v);
         cursor_ = (v) ? valid : eos;
      }
   };

   template<typename _C1, typename _D1, typename _C2, typename _D2>
   inline bool operator== (const istreamdev_it<_C1, _D1>& lhs,
                           const istreamdev_it<_C2, _D2>& rhs) noexcept {
      return ((lhs.owner() == rhs.owner()) &&
              (lhs.value() == rhs.value()) &&
              (lhs.cursor() == rhs.cursor()));
   }
   template<typename _C1, typename _D1, typename _C2, typename _D2>
   inline bool operator!= (const istreamdev_it<_C1, _D1>& lhs,
                           const istreamdev_it<_C2, _D2>& rhs) noexcept {
      return !operator==(lhs, rhs);
   }

   template<typename cont_t, typename iter_t, index_t _beg =0, index_t _end =static_cast<index_t>(-1)>
   class outdev_it {
      using iterator_t = outdev_it <cont_t, iter_t, _beg, _end>;
   public:
      using type       = iterator_t;    
   public:
      using iterator_category = typename dev_iterator_traits <std::output_iterator_tag, iter_t>::iterator_category;
      using value_type        = typename dev_iterator_traits <std::output_iterator_tag, iter_t>::value_type;
      using difference_type   = typename dev_iterator_traits <std::output_iterator_tag, iter_t>::difference_type;
      using pointer           = typename dev_iterator_traits <std::output_iterator_tag, iter_t>::pointer;
      using reference         = typename dev_iterator_traits <std::output_iterator_tag, iter_t>::reference;
      enum Cursor {
         beg   = _beg,     
         eod   = _end,     
      };
   private:
      cont_t*  owner_ {nullptr}; 
      index_t  cursor_ {eod};    

   public:
      explicit outdev_it() noexcept :
         owner_ {nullptr},
         cursor_{eod} { }
      explicit outdev_it (cont_t* owner, index_t cursor =eod) noexcept :
         owner_ {owner},
         cursor_{cursor} { }
      explicit outdev_it (const iterator_t& it) noexcept :
         owner_ {const_cast<cont_t*>(it.owner_)},
         cursor_{it.cursor_} { }
      iterator_t& operator= (const iterator_t& it) noexcept {
         owner_ = const_cast<cont_t*>(it.owner_);
         cursor_ = it.cursor_;
      }
//      template<typename _It>
//      outdev_it (const outdev_it<
//                          use_if_same_t <_It, typename container_t::pointer_type, container_t>,
//                          _It,
//                          streamsize
//                       >& it) noexcept
//         : owner_ {const_cast<container_t*>(it.owner())},
//           cursor_ {it.cursor()} { }


   public:
      iterator_t& operator* () noexcept { return *this; }
      iterator_t& operator= (const value_type& value) {
         // end() and default constructible iterators are not dereferenceable
         if (cursor_ != eod)
            owner_->put (value, cursor_);
         return *this;
      }

      iterator_t& operator++ () noexcept {
         ++cursor_;
         return *this;
      }
      iterator_t operator++ (int) noexcept {
         iterator_t ret = *this;
         ++cursor_;
         return ret;
      }

      const cont_t*  owner () const noexcept { return owner_; }
      const index_t cursor () const noexcept { return cursor_; }
   };


   template<typename _Cont1, typename _It1, index_t _beg1, index_t _end1,
            typename _Cont2, typename _It2, index_t _beg2, index_t _end2>
   inline bool operator== (const outdev_it<_Cont1, _It1, _beg1, _end1>& lhs,
                           const outdev_it<_Cont2, _It2, _beg2, _end2>& rhs) noexcept {
      return ((lhs.cursor() == rhs.cursor()) &&
              (lhs.owner() == rhs.owner()));
   }

   template<typename _Cont1, typename _It1, index_t _beg1, index_t _end1,
            typename _Cont2, typename _It2, index_t _beg2, index_t _end2>
   inline bool operator!= (const outdev_it<_Cont1, _It1, _beg1, _end1>& lhs,
                           const outdev_it<_Cont2, _It2, _beg2, _end2>& rhs) noexcept {
      return !(lhs == rhs);
   }

   #if defined _utl_have_concepts
      template <typename T>
      concept bool Outdev_it = requires (T t) {
         // STL compatibility
         typename T::value_type;
         typename T::difference_type;
         typename T::pointer;
         typename T::reference;
         requires same_<
            typename T::iterator_category,
            std::output_iterator_tag
         >::value;
         {*t} -> auto&&;   // is dereferencable, and return non-void
         {++t} -> T&;      // is incrementable
         {t++} -> T;
         // Extras
         {t.owner()} ->auto&&;
         {t.cursor()} -> size_t;
      };
   #else
      namespace outdev_it_details {
         using std::declval;

         template <typename _Tp, typename =void>
         struct is_outdev_it_ : meta::false_ {};

         template <typename _Tp>
         struct is_outdev_it_ <
            _Tp,
            meta::void_t <
               typename _Tp::value_type,
               typename _Tp::difference_type,
               typename _Tp::pointer,
               typename _Tp::reference,
//               meta::use_if_same_t <
//                  typename _Tp::iterator_category,
//                  std::output_iterator_tag
//               >
            void
            >
         > : meta::true_ {};
      }
//      template <typename _Tp>
//      constexpr bool Outdev_it = outdev_it_details::is_outdev_it_<_Tp>::value;
   #endif


   /*
    * ================ Input device Iterator =================
    */

   template<typename cont_t, typename iter_t, index_t _beg =0, size_t _size = static_cast<size_t>(-1)-_beg>
   class indev_it {
      using iterator_t = indev_it <cont_t, iter_t, _beg, _size>;
   public:
      using type       = iterator_t;    
   public:
      using iterator_category = typename dev_iterator_traits <std::output_iterator_tag, iter_t>::iterator_category;
      using value_type        = typename dev_iterator_traits <std::output_iterator_tag, iter_t>::value_type;
      using difference_type   = typename dev_iterator_traits <std::output_iterator_tag, iter_t>::difference_type;
      using pointer           = typename dev_iterator_traits <std::output_iterator_tag, iter_t>::pointer;
      using reference         = typename dev_iterator_traits <std::output_iterator_tag, iter_t>::reference;

      enum Cursor {
         beg = _beg,          
         eod = _beg + _size,  
      };

   private:
      cont_t*      owner_{nullptr}; 
      index_t      cursor_{eod};    
      value_type   value_ {};       

   public:
      indev_it () noexcept :
         owner_ {nullptr},
         cursor_{eod},
         value_ {} { }
      explicit indev_it (cont_t* own, size_t cur =eod) noexcept :
         owner_ {own},
         cursor_{cur},
         value_ {} { }
      explicit indev_it (const iterator_t& it) noexcept :
         owner_ {const_cast<cont_t*>(it.owner_)},
         cursor_{it.cursor_},
         value_ {it.value_} { }
      iterator_t& operator= (const iterator_t& it) noexcept {
        owner_  = const_cast<cont_t*>(it.owner_);
        cursor_ = it.cursor_;
        value_  = it.value_;
      }
//      template<typename _It>
//      indev_it (const indev_it<
//                         use_if_same_t <_It, typename container_t::pointer_type, container_t>,
//                         _It,
//                         streamsize
//                      >& it) noexcept
//         : owner_ {const_cast<container_t*>(it.owner())},
//           cursor_{it.cursor()},
//           value_ {it.value()} { }


   public:
      reference operator* () {
         owner_->get (value_, cursor_);
         return value_;
      }
      pointer operator-> () {
         owner_->get (value_, cursor_);
         return &value_;
      }

      iterator_t& operator++ () {
         ++cursor_;
         return *this;
      }
      iterator_t operator++ (int) {
         iterator_t ret(*this);
         ++cursor_;
         return *this;
      }

      iterator_t& operator-- () {
         --cursor_;
         return *this;
      }
      iterator_t operator-- (int) {
         iterator_t ret(*this);
         --cursor_;
         return *this;
      }
      reference operator[] (difference_type n) {
         owner_->get (value_, cursor_ += n);
         return value_;
      }

      iterator_t& operator+= (difference_type n) {
         cursor_ += n;
         return *this;
      }
      iterator_t operator+ (difference_type n) {
         return iterator_t (owner_, cursor_ + n);
      }
      iterator_t& operator-= (difference_type n) {
         cursor_ -= n;
         return *this;
      }
      iterator_t operator- (difference_type n) {
         return iterator_t (owner_, cursor_ - n);
      }
      const cont_t*  owner () const noexcept { return owner_; }
      const index_t cursor () const noexcept { return cursor_; }
      //const reference value () const noexcept { return value_; }
   };

   template<typename _Cont1, typename _It1, index_t _beg1, size_t _size1,
            typename _Cont2, typename _It2, index_t _beg2, size_t _size2>
   inline bool operator== (const indev_it<_Cont1, _It1, _beg1, _size1>& x,
                           const indev_it<_Cont2, _It2, _beg2, _size2>& y) noexcept {
      return (x.owner()  == y.owner()   &&
             (x.cursor() == y.cursor()));
   }
   template<typename _Cont1, typename _It1, index_t _beg1, size_t _size1,
            typename _Cont2, typename _It2, index_t _beg2, size_t _size2>
   inline bool operator< (const indev_it<_Cont1, _It1, _beg1, _size1>& x,
                          const indev_it<_Cont2, _It2, _beg2, _size2>& y) noexcept {
      return (x.cursor() < y.cursor());
   }

   // relative ops
   template<typename _Cont1, typename _It1, index_t _beg1, size_t _size1,
            typename _Cont2, typename _It2, index_t _beg2, size_t _size2>
   inline bool operator!= (const indev_it<_Cont1, _It1, _beg1, _size1>& x,
                           const indev_it<_Cont2, _It2, _beg2, _size2>& y) noexcept {
      return !(x == y);
   }
   template<typename _Cont1, typename _It1, index_t _beg1, size_t _size1,
            typename _Cont2, typename _It2, index_t _beg2, size_t _size2>
   inline bool operator<= (const indev_it<_Cont1, _It1, _beg1, _size1>& x,
                           const indev_it<_Cont2, _It2, _beg2, _size2>& y) noexcept {
      return !(y < x);
   }
   template<typename _Cont1, typename _It1, index_t _beg1, size_t _size1,
            typename _Cont2, typename _It2, index_t _beg2, size_t _size2>
   inline bool operator> (const indev_it<_Cont1, _It1, _beg1, _size1>& x,
                          const indev_it<_Cont2, _It2, _beg2, _size2>& y) noexcept {
      return (y < x);
   }
   template<typename _Cont1, typename _It1, index_t _beg1, size_t _size1,
            typename _Cont2, typename _It2, index_t _beg2, size_t _size2>
   inline bool operator>= (const indev_it<_Cont1, _It1, _beg1, _size1>& x,
                           const indev_it<_Cont2, _It2, _beg2, _size2>& y) noexcept {
      return !(x < y);
   }

   template<typename _Cont1, typename _It1, index_t _beg1, size_t _size1,
            typename _Cont2, typename _It2, index_t _beg2, size_t _size2>
   inline auto operator- (indev_it<_Cont1, _It1, _beg1, _size1>& x,
                          indev_it<_Cont1, _It1, _beg1, _size1>& y) noexcept
   -> decltype (x.cursor() - y.cursor()) {
      return (x.cursor() - y.cursor());
   }

   template<typename _Cont, typename _It, index_t _beg, size_t _size>
   inline indev_it<_Cont, _It, _beg, _size>
      operator+ (typename _Cont::difference_type n,
                 indev_it<_Cont, _It, _beg, _size>& it) noexcept {
      return indev_it<_Cont, _It, _beg, _size>(it.owner(), it.cursor() + n);
   }

   #if defined _utl_have_concepts
      template <typename T>
      concept bool Indev_it = requires (T t, const T ct) {
         // STL compatibility
         typename T::value_type;
         typename T::difference_type;
         typename T::pointer;
         typename T::reference;
         requires same_ <
            typename T::iterator_category,
            std::input_iterator_tag
         >::value;
         {*t} -> typename T::value_type;   // is dereferencable
         {++t} -> T&;      // is incrementable
         {t++} -> T;
         // Extras
         {ct.owner()} ->auto&&;
         {ct.cursor()} -> const size_t;
         {ct.value()} -> auto&&;
      };
   #else
      namespace indev_it_details {
         using std::declval;

         template <typename _Tp, typename =void>
         struct is_indev_it_ : meta::false_ {};

         template <typename _Tp>
         struct is_indev_it_ <
            _Tp,
            meta::void_t <
               typename _Tp::value_type,
               typename _Tp::difference_type,
               typename _Tp::pointer,
               typename _Tp::reference,
//               meta::use_if_same_t <
//                  typename _Tp::iterator_category,
//                  std::input_iterator_tag
//               >
               void
            >
         > : meta::true_ {};
      }
//      template <typename _Tp>
//      constexpr bool Indev_it = indev_it_details::is_indev_it_<_Tp>::value;
   #endif

   /*
    * ================= Indexed device Iterator =================
    */

   template<typename cont_t, typename iter_t, index_t _beg =0, size_t _size = static_cast<size_t>(-1)-_beg>
   class iodev_it {
      using iterator_t = iodev_it <cont_t, iter_t, _beg, _size>;
   public:
      using type       = iterator_t;    
   public:
      using iterator_category = typename dev_iterator_traits <std::output_iterator_tag, iter_t>::iterator_category;
      using value_type        = typename dev_iterator_traits <std::output_iterator_tag, iter_t>::value_type;
      using difference_type   = typename dev_iterator_traits <std::output_iterator_tag, iter_t>::difference_type;
      using pointer           = typename dev_iterator_traits <std::output_iterator_tag, iter_t>::pointer;
      using reference         = typename dev_iterator_traits <std::output_iterator_tag, iter_t>::reference;

      enum Cursor {
         beg = _beg,          
         eod = _beg+_size,    
      };

   private:
      cont_t*      owner_{nullptr}; 
      index_t      cursor_{eod};    

      struct value_type_t {
         value_type v_;                
         value_type_t(value_type v =value_type{}) :
            v_{v} { }
         operator value_type() { return v_; }
         operator reference()  { return v_; }
         value_type& operator= (const value_type& v) {
            owner_->put (v_ =v, cursor_);
         }
      } value_ {};
   public:
      iodev_it () noexcept :
         owner_ {nullptr},
         cursor_{eod},
         value_ {} { }
      explicit iodev_it (cont_t* owner, size_t cursor =eod) noexcept :
         owner_ {owner},
         cursor_{cursor},
         value_ {} { }
      explicit iodev_it (const iterator_t& it) noexcept :
         owner_ {const_cast<cont_t*>(it.owner_)},
         cursor_{it.cursor_},
         value_ {it.value_} { }
      iterator_t& operator= (const iterator_t& it) noexcept {
        owner_  = const_cast<cont_t*>(it.owner_);
        cursor_ = it.cursor_;
        value_  = it.value_;
      }

   public:
      reference operator* () noexcept {
         owner_->get (value_.v_, cursor_);
         return value_;
      }
      pointer operator-> () noexcept {
         owner_->get (value_.v_, cursor_);
         return &value_;
      }

      iterator_t& operator++ () noexcept {
         ++cursor_;
         return *this;
      }
      iterator_t operator++ (int) noexcept {
         iterator_t ret = *this;
         ++cursor_;
         return *this;
      }
      iterator_t& operator-- () noexcept {
         --cursor_;
         return *this;
      }
      iterator_t operator-- (int) noexcept {
         iterator_t ret = *this;
         --cursor_;
         return *this;
      }
      reference operator[] (difference_type n) noexcept {
         owner_->get (value_.v_, cursor_ = n);
         return value_;
      }
      iterator_t& operator+= (difference_type n) noexcept {
         cursor_ += n;
         return *this;
      }
      iterator_t operator+ (difference_type n) const noexcept {
         return iterator_t (owner_, cursor_ + n);
      }
      iterator_t& operator-= (difference_type n) noexcept {
         cursor_ -= n;
         return *this;
      }
      iterator_t operator- (difference_type n) const noexcept {
         return iterator_t (owner_, cursor_ - n);
      }

      const cont_t*   owner () const noexcept { return owner_; }
      const index_t& cursor () const noexcept { return cursor_; }
      //const value_type_t& value () const noexcept { return value_; }
   };

   template<typename _Cont1, typename _It1, index_t _beg1, size_t _size1,
            typename _Cont2, typename _It2, index_t _beg2, size_t _size2>
   inline bool operator== (const iodev_it<_Cont1, _It1, _beg1, _size1>& x,
                           const iodev_it<_Cont2, _It2, _beg2, _size2>& y) noexcept {
      return (x.owner()  == y.owner()   &&
             (x.cursor() == y.cursor()));
   }
   template<typename _Cont1, typename _It1, index_t _beg1, size_t _size1,
            typename _Cont2, typename _It2, index_t _beg2, size_t _size2>
   inline bool operator< (const iodev_it<_Cont1, _It1, _beg1, _size1>& x,
                          const iodev_it<_Cont2, _It2, _beg2, _size2>& y) noexcept {
      return (x.cursor() < y.cursor());
   }

   // relative ops
   template<typename _Cont1, typename _It1, index_t _beg1, size_t _size1,
            typename _Cont2, typename _It2, index_t _beg2, size_t _size2>
   inline bool operator!= (const iodev_it<_Cont1, _It1, _beg1, _size1>& x,
                           const iodev_it<_Cont2, _It2, _beg2, _size2>& y) noexcept {
      return !(x == y);
   }
   template<typename _Cont1, typename _It1, index_t _beg1, size_t _size1,
            typename _Cont2, typename _It2, index_t _beg2, size_t _size2>
   inline bool operator<= (const iodev_it<_Cont1, _It1, _beg1, _size1>& x,
                           const iodev_it<_Cont2, _It2, _beg2, _size2>& y) noexcept {
      return !(y < x);
   }
   template<typename _Cont1, typename _It1, index_t _beg1, size_t _size1,
            typename _Cont2, typename _It2, index_t _beg2, size_t _size2>
   inline bool operator> (const iodev_it<_Cont1, _It1, _beg1, _size1>& x,
                          const iodev_it<_Cont2, _It2, _beg2, _size2>& y) noexcept {
      return (y < x);
   }
   template<typename _Cont1, typename _It1, index_t _beg1, size_t _size1,
            typename _Cont2, typename _It2, index_t _beg2, size_t _size2>
   inline bool operator>= (const iodev_it<_Cont1, _It1, _beg1, _size1>& x,
                           const iodev_it<_Cont2, _It2, _beg2, _size2>& y) noexcept {
      return !(x < y);
   }

   template<typename _Cont1, typename _It1, index_t _beg1, size_t _size1,
            typename _Cont2, typename _It2, index_t _beg2, size_t _size2>
   inline auto operator- (iodev_it<_Cont1, _It1, _beg1, _size1>& x,
                          iodev_it<_Cont1, _It1, _beg1, _size1>& y) noexcept
   -> decltype (x.cursor() - y.cursor()) {
      return (x.cursor() - y.cursor());
   }

   template<typename _Cont, typename _It, index_t _beg, size_t _size>
   inline iodev_it<_Cont, _It, _beg, _size>
      operator+ (typename _Cont::difference_type n,
                 iodev_it<_Cont, _It, _beg, _size>& it) noexcept {
      return iodev_it<_Cont, _It, _beg, _size>(it.owner(), it.cursor() + n);
   }

   #if defined _utl_have_concepts
      template <typename T>
      concept bool Idxdev_it = requires (T t, const T ct) {
         // STL compatibility
         typename T::value_type;
         typename T::difference_type;
         typename T::pointer;
         typename T::reference;
         requires same_<
            typename T::iterator_category,
            std::input_iterator_tag
         >::value;
         {*t} -> typename T::value_type;   // is dereferencable
         {++t} -> T&;      // is incrementable
         {t++} -> T;
         // Extras
         {ct.owner()} ->auto&&;
         {ct.cursor()} -> const size_t;
         {ct.value()} -> auto&&;
      };
   #else
      namespace idxdev_it_details {
         using std::declval;

         template <typename _Tp, typename =void>
         struct is_idxdev_it_ : meta::false_ {};

         template <typename _Tp>
         struct is_idxdev_it_ <
            _Tp,
            meta::void_t <
               typename _Tp::value_type,
               typename _Tp::difference_type,
               typename _Tp::pointer,
               typename _Tp::reference,
//               meta::use_if_same_t <
//                  typename _Tp::iterator_category,
//                  std::input_iterator_tag
//               >
               void
            >
         > : meta::true_ {};
      }
//      template <typename _Tp>
//      constexpr bool Idxdev_it = idxdev_it_details::is_idxdev_it_<_Tp>::value;
   #endif

}
#endif /* __utl_dev_dev_iterators_h__ */