transform_iterator.h

Go to the documentation of this file.

/*
 *  This file is a part of TiledArray.
 *  Copyright (C) 2013  Virginia Tech
 *
 *  This program 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 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef TILEDARRAY_TRANSFORM_ITERATOR_H__INCLUDED
#define TILEDARRAY_TRANSFORM_ITERATOR_H__INCLUDED

#include <cstddef>
#include <TiledArray/madness.h>

namespace TiledArray {
  namespace detail {

    namespace {


      template <typename T>
      class PointerProxy {
      public:

        PointerProxy(const T& value) : value_(value) { }


        T* operator->() const { return &value_; }

        operator T*() const { return &value_; }
      private:
        mutable T value_; 
      }; // class PointerProxy
    } // namespace



    template <typename Iter1, typename Iter2, typename Op>
    class BinaryTransformIterator {
    private:
      // Give access to other Transform iterator types.
      template <typename, typename, typename>
      friend class BinaryTransformIterator;

    public:
      typedef std::ptrdiff_t difference_type;                     
      typedef typename madness::detail::result_of<Op>::type value_type;
      typedef PointerProxy<value_type> pointer;                   
      typedef value_type reference;                               
      typedef std::input_iterator_tag iterator_category;          
      typedef BinaryTransformIterator<Iter1, Iter2, Op> this_type;
      typedef Iter1 base_iterator1;                               
      typedef Iter2 base_iterator2;                               


      BinaryTransformIterator(Iter1 it1, Iter2 it2, Op op = Op()) :
          it1_(it1), it2_(it2), op_(op)
      { }


      BinaryTransformIterator(const this_type& other) :
          it1_(other.it1_), it2_(other.it2_), op_(other.op_)
      { }


      template <typename It1, typename It2>
      BinaryTransformIterator(const BinaryTransformIterator<It1, It2, Op>& other) :
          it1_(other.it1_), it2_(other.it2_), op_(other.op_)
      { }


      this_type& operator=(const this_type& other) {
        it1_ = other.it1_;
        it2_ = other.it2_;
        op_ = other.op_;

        return *this;
      }


      template <typename It1, typename It2>
      this_type& operator=(const BinaryTransformIterator<It1, It2, Op>& other) {
        it1_ = other.it1_;
        it2_ = other.it2_;
        op_ = other.op_;

        return *this;
      }


      this_type& operator++() {
        increment();
        return *this;
      }


      this_type operator++(int) {
        this_type tmp(*this);
        increment();
        return tmp;
      }


      template <typename It1, typename It2>
      bool operator==(const BinaryTransformIterator<It1, It2, Op>& other) const {
        return equal(other);
      }


      template <typename It1, typename It2>
      bool operator!=(const BinaryTransformIterator<It1, It2, Op>& other) const {
        return ! equal(other);
      }


      reference operator*() { return dereference(); }


      pointer operator->() { return pointer(dereference()); }


      base_iterator1 base1() const { return it1_; }


      base_iterator2 base2() const { return it2_; }

    private:
      void increment() { ++it1_; ++it2_; }


      template <typename It1, typename It2>
      bool equal(const BinaryTransformIterator<It1, It2, Op>& other) const {
        return (it1_ == other.it1_) && (it2_ == other.it2_);
      }


      reference dereference() const { return op_(*it1_, *it2_); }

      base_iterator1 it1_;  
      base_iterator2 it2_;  
      Op op_;               
    }; // class BinaryTransformIterator



    template <typename Iter, typename Op>
    class UnaryTransformIterator {
    private:
      // Give access to other Transform iterator types.
      template <typename, typename>
      friend class UnaryTransformIterator;

    public:
      typedef ptrdiff_t difference_type;                        
      typedef typename madness::detail::result_of<Op>::type value_type; 
      typedef PointerProxy<value_type> pointer;                 
      typedef value_type reference;                             
      typedef std::input_iterator_tag iterator_category;        
      typedef UnaryTransformIterator<Iter, Op> this_type;       
      typedef Iter base_iterator;                               


      UnaryTransformIterator(Iter it, Op op = Op()) :
          it_(it), op_(op)
      { }


      UnaryTransformIterator(const this_type& other) :
          it_(other.it_), op_(other.op_)
      { }


      template <typename It>
      UnaryTransformIterator(const UnaryTransformIterator<It, Op>& other) :
          it_(other.it_), op_(other.op_)
      { }


      this_type& operator=(const this_type& other) {
        it_ = other.it_;
        op_ = other.op_;

        return *this;
      }


      template <typename It>
      this_type& operator=(const UnaryTransformIterator<It, Op>& other) {
        it_ = other.it_;
        op_ = other.op_;

        return *this;
      }


      this_type& operator++() {
        increment();
        return *this;
      }


      this_type operator++(int) {
        this_type tmp(*this);
        increment();
        return tmp;
      }


      template <typename It>
      bool operator==(const UnaryTransformIterator<It, Op>& other) const {
        return equal(other);
      }


      template <typename It>
      bool operator!=(const UnaryTransformIterator<It, Op>& other) const {
        return ! equal(other);
      }


      reference operator*() const { return dereference(it_); }


      pointer operator->() const { return pointer(dereference(it_)); }


      base_iterator base() const { return it_; }

    private:

      void increment() { ++it_; }


      template <typename It>
      bool equal(const UnaryTransformIterator<It, Op>& other) const {
        return it_ == other.it_;
      }


      template <typename It>
      typename std::enable_if<! std::is_integral<It>::value, reference>::type
      dereference(It it) const { return op_(*it); }



      template <typename It>
      typename std::enable_if<std::is_integral<It>::value, reference>::type
      dereference(It it) const { return op_(it); }

      base_iterator it_;  
      Op op_;             
    }; // class UnaryTransformIterator



    template <typename Iter1, typename Iter2, typename Op>
    BinaryTransformIterator<Iter1, Iter2, Op> make_tran_it(Iter1 it1, Iter2 it2, Op op) {
      return BinaryTransformIterator<Iter1, Iter2, Op>(it1, it2, op);
    }


    template <typename Iter, typename Op>
    UnaryTransformIterator<Iter, Op> make_tran_it(Iter it, Op op) {
      return UnaryTransformIterator<Iter, Op>(it, op);
    }

  } // namespace detail
} // namespace TiledArray

#endif // TILEDARRAY_TRANSFORM_ITERATOR_H__INCLUDED