iter-adapter-ptr-deref.hpp

Go to the documentation of this file.

/*
  ITER-ADAPTER-PTR-DEREF.hpp  -  wrapping iterator to dereference pointers automatically
 
   Copyright (C)
     2015,            Hermann Vosseler <Ichthyostega@web.de>
 
 **Lumiera** is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
 Free Software Foundation; either version 2 of the License, or (at your
 option) any later version. See the file COPYING for further details.
 
*/
 
 
#ifndef LIB_ITER_ADAPTER_PTR_DEREF_H
#define LIB_ITER_ADAPTER_PTR_DEREF_H
 
 
#include "lib/iter-adapter.hpp"
 
#include <type_traits>
 
 
namespace lib {
  
  
  template<class IT>
  class PtrDerefIter
    {
      IT i_;  
      
      
    public:
      using pointer    = meta::ValueTypeBinding<IT>::value_type;
      static_assert(std::is_pointer_v<pointer>);
      
      using value_type = std::remove_pointer_t<pointer>;
      using reference  = value_type&;
      
      
      ENABLE_USE_IN_STD_RANGE_FOR_LOOPS (PtrDerefIter);
      
      
      // the purpose of the following typedefs is to support building a correct "const iterator"
      
      using ValueTypeBase = std::remove_const_t<value_type>; // value_type without const
      
      using WrappedIterType      = IterType<IT>::template SimilarIter<      ValueTypeBase* * >::Type;
      using WrappedConstIterType = IterType<IT>::template SimilarIter<const ValueTypeBase* * >::Type;
      
      using IterType      = PtrDerefIter<WrappedIterType>;
      using ConstIterType = PtrDerefIter<WrappedConstIterType>;
      
      
      
      explicit
      PtrDerefIter (IT srcIter)
        : i_{srcIter}
        { }
      
      PtrDerefIter()
        : i_{}
        { }
      
      
      PtrDerefIter (PtrDerefIter<WrappedIterType> const& oIter)
        : i_(reinterpret_cast<IT const&> (oIter.getBase()))
        { }
      
      PtrDerefIter&
      operator= (PtrDerefIter<WrappedIterType> const& ref)
        {
          i_ = reinterpret_cast<IT const&> (ref.getBase());
          return *this;
        }
      
      explicit
      operator bool() const
        {
          return isValid();
        }
      
      
      
      static PtrDerefIter
      build_by_cast (WrappedIterType const& srcIter)
        {
          return PtrDerefIter (reinterpret_cast<IT const&> (srcIter));
        }
      
      static PtrDerefIter
      nil()
        {
          return PtrDerefIter (IT());
        }
      
      
      
      
      
      
      /* === lumiera forward iterator concept === */
      
      reference
      operator*() const
        {
          return *(*i_);
        }
      
      pointer
      operator->() const
        {
          return *i_;
        }
      
      PtrDerefIter&
      operator++()
        {
          ++i_;
          return *this;
        }
      
      bool
      isValid ()  const
        {
          return bool(i_);
        }
      
      bool
      empty ()    const
        {
          return not isValid();
        }
      
      
      IT const&
      getBase()  const
        {
          return i_;
        }
    };
  
  
  template<class I1, class I2>
  bool operator== (PtrDerefIter<I1> const& il, PtrDerefIter<I2> const& ir)  { return il.getBase() == ir.getBase(); }
    
  template<class I1, class I2>
  bool operator!= (PtrDerefIter<I1> const& il, PtrDerefIter<I2> const& ir)  { return not (il == ir); }
  
  
  template<class IT>
  auto
  ptrDeref (IT iter)
  {
    return PtrDerefIter<IT>{iter};
  }
  
  
  
  
  template<class IT>
  class AddressExposingIter
    {
      using _Ptr = IT::pointer;
      
      IT i_;  
      
      mutable _Ptr currPtr_;
      
      
      void
      takeAddress()
        {
          if (i_.isValid())
            currPtr_ = & (*i_);
          else
            currPtr_ = nullptr;
        }
      
      
    public:
      using pointer    = IT::pointer const*;
      using reference  = IT::pointer const&;
      using value_type = IT::pointer const ;
      
      ENABLE_USE_IN_STD_RANGE_FOR_LOOPS (AddressExposingIter);
      
      
      explicit
      AddressExposingIter (IT srcIter)
        : i_(srcIter)
        {
          takeAddress();
        }
      
      explicit
      operator bool() const
        {
          return isValid();
        }
      
      
      
      
      /* === lumiera forward iterator concept === */
      
      reference
      operator*() const
        {
          return currPtr_;
        }
      
      _Ptr
      operator->() const
        {
          return currPtr_;
        }
      
      AddressExposingIter&
      operator++()
        {
          ++i_;
          takeAddress();
          return *this;
        }
      
      bool
      isValid ()  const
        {
          return bool(i_);
        }
      
      bool
      empty ()    const
        {
          return not isValid();
        }
      
      
      IT const&
      getBase()  const
        {
          return i_;
        }
    };
  
  
  template<class I1, class I2>
  bool operator== (AddressExposingIter<I1> const& il, AddressExposingIter<I2> const& ir)  { return il.getBase() == ir.getBase(); }
    
  template<class I1, class I2>
  bool operator!= (AddressExposingIter<I1> const& il, AddressExposingIter<I2> const& ir)  { return not (il == ir); }
  
  
  
  
  
  
}// namespace lib
#endif /*LIB_ITER_ADAPTER_PTR_DEREF_H*/