iterator_traits.h

#ifndef _theplu_yat_utility_iterator_traits_
#define _theplu_yat_utility_iterator_traits_

// $Id: iterator_traits.h 3188 2014-03-25 10:24:29Z peter $

/*
  Copyright (C) 2007 Jari Häkkinen, Peter Johansson
  Copyright (C) 2008 Jari Häkkinen, Peter Johansson, Markus Ringnér
  Copyright (C) 2010, 2011, 2014 Peter Johansson

  This file is part of the yat library, http://dev.thep.lu.se/yat

  The yat library 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.

  The yat library 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 yat. If not, see <http://www.gnu.org/licenses/>.
*/

#include "DataWeight.h"

#include <boost/mpl/logical.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/utility/enable_if.hpp>

#include <iterator>

namespace theplu {
namespace yat {
namespace utility {

  struct unweighted_iterator_tag {};
    
  struct weighted_iterator_tag {};



namespace detail {
  template <typename T, typename Enable = void>
  struct weighted_iterator_traits_detail {
    typedef unweighted_iterator_tag type;
  };  

  template <typename T>
  struct weighted_iterator_traits_detail<T, typename boost::enable_if<typename boost::is_convertible<T, DataWeight> >::type > {
    typedef weighted_iterator_tag type;
  };  

} // namespace detail



  template <class Iterator>
  struct weighted_iterator_traits 
  {
  private:
    typedef typename std::iterator_traits<Iterator>::value_type value;
  public:
    typedef typename detail::weighted_iterator_traits_detail<value>::type type;
  };


namespace detail {
  template <class T1, class T2>
  struct unweighted_type_and {
    typedef weighted_iterator_tag type;
  };

  template <>
  struct unweighted_type_and<unweighted_iterator_tag, unweighted_iterator_tag> {
    typedef unweighted_iterator_tag type;
  };
} // namespace detail



  template <class T1, class T2>
  struct weighted_if_any2 {
  private:
    typedef typename weighted_iterator_traits<T1>::type w_type1;
    typedef typename weighted_iterator_traits<T2>::type w_type2;
  public:
    typedef typename detail::unweighted_type_and<w_type1, w_type2>::type type;
  };

  template <class T1, class T2, class T3>
  struct weighted_if_any3 {
  private:
    typedef typename weighted_if_any2<T1, T2>::type tmp;
    typedef typename weighted_iterator_traits<T3>::type w_type3;
  public:
    typedef typename detail::unweighted_type_and<tmp, w_type3>::type type;
  };

  namespace detail {
    inline void 
    check_iterator_is_unweighted(utility::unweighted_iterator_tag x){} 
  } // namespace detail


  template <class Iter>
  void check_iterator_is_unweighted(Iter iter) 
  { detail::check_iterator_is_unweighted(typename 
                                 weighted_iterator_traits<Iter>::type());
  }


namespace detail {

  typedef char yes;
  typedef char (&no)[2];
  yes has_mutable(double&);
  template<typename T>
  no has_mutable(const T&);

  template <class Iter>
  struct iter_has_mutable_data
  {
    static Iter iter;
    static const bool value = 
      sizeof(has_mutable((*iter).data())) == sizeof(yes);
  };


  template <class Iter>
  struct iter_has_mutable_weight
  {
    static Iter iter;
    static const bool value = 
      sizeof(has_mutable((*iter).weight())) == sizeof(yes);
  };


  template<typename Iter>
  struct is_weighted 
    : public boost::is_same<weighted_iterator_tag
                            , typename weighted_iterator_traits<Iter>::type> 
  {};

  template<typename Iter>
  struct is_unweighted 
    : public boost::is_same<unweighted_iterator_tag
                            , typename weighted_iterator_traits<Iter>::type> 
  {};


  template <typename Iter, typename Enable = void>
  struct iterator_traits_detail {
    typedef typename std::iterator_traits<Iter>::reference data_reference;

    typedef const double weight_reference;

    data_reference data(Iter iter) const { return *iter; }

    weight_reference weight(Iter iter) const { return 1.0; }
  };

  template<bool>
  struct mutable_reference {
    typedef const double type;
  };

  template<>
  struct mutable_reference<true> {
    typedef double& type;
  };


  // we need remove_reference because is_const seems to not work on const&
  template <typename Iter>
  struct iterator_traits_detail<Iter, 
                         typename boost::enable_if<is_weighted<Iter> >::type >
  {
    typedef 
    typename mutable_reference<iter_has_mutable_data<Iter>::value>::type 
    data_reference;

    typedef 
    typename mutable_reference<iter_has_mutable_weight<Iter>::value>::type 
    weight_reference;

    data_reference data(Iter iter) const { return (*iter).data(); }

    weight_reference weight(Iter iter) const { return (*iter).weight(); }
  };

} // namespace detail



  template <typename Iter>
  struct iterator_traits {
  private:
    typedef detail::iterator_traits_detail<Iter> traits;
  public:
    typedef typename traits::data_reference data_reference;

    typedef typename traits::weight_reference weight_reference;

    data_reference data(Iter iter) const 
    { return traits().data(iter); }

    weight_reference weight(Iter iter) const 
    { return traits().weight(iter); }

  };

}}} // of namespace utility, yat, and theplu

#endif