WeightedIteratorArchetype.h

#ifndef _theplu_yat_utility_weighted_iterator_archetype
#define _theplu_yat_utility_weighted_iterator_archetype

// $Id: WeightedIteratorArchetype.h 3569 2017-01-09 03:43:08Z peter $

/*
  Copyright (C) 2014, 2015, 2016, 2017 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 <yat/utility/DataWeight.h>
#include <yat/utility/DataWeightProxy.h>

#include <boost/iterator/iterator_archetypes.hpp>
#include <boost/iterator/iterator_concepts.hpp>
#include <boost/iterator/iterator_facade.hpp>

namespace theplu {
namespace yat {
namespace utility {

  // Could have been a class inside of weighted_iterator_archetype,
  // but we don't want it to be templatized.
  struct WeightedIteratorArchetype_ctor_arg {};

  // Some private aux classes for weighted_iterator_archetype
  namespace detail {
  namespace weighted_iterator_archetype {
    struct bogus {};

    // Classes calculating the reference type

    // default, not implemented
    template<class AccessCategory> struct Reference {};

    // readable iterators return const data weight proxy
    template<>
    struct Reference<boost::iterator_archetypes::readable_iterator_t>
    {
      typedef const utility::DataWeightProxy<const double*, const double*> type;
    };


    // readable_writable iterators return mutable data weight proxy
    template<>
    struct Reference<boost::iterator_archetypes::readable_writable_iterator_t>
    {
      typedef utility::DataWeightProxy<double*, double*> type;
    };


    // Classes defining difference type based on traversal category

    // Default no difference type defined
    template<class TraversalCategory> struct Difference {};

    // If traversal is at least forward traversal, int is returned,
    // otherwise a bogus class is returned.

    template<>
    struct Difference<boost::incrementable_traversal_tag>
    { typedef bogus type; };

    template<>
    struct Difference<boost::single_pass_traversal_tag>
    { typedef bogus type; };

    template<>
    struct Difference<boost::forward_traversal_tag>
    { typedef int type; };

    template<>
    struct Difference<boost::bidirectional_traversal_tag>
    { typedef int type; };

    template<>
    struct Difference<boost::random_access_traversal_tag>
    { typedef int type; };

  } // end of namespace weighted_iterator_archetype
  } // end of namespace detail

  template<typename AccessCategory, typename TraversalCategory>
  class WeightedIteratorArchetype
    : public boost::iterator_facade<
    WeightedIteratorArchetype<AccessCategory, TraversalCategory>
    , DataWeight
    , TraversalCategory
    , typename detail::weighted_iterator_archetype::Reference<AccessCategory>::type
    , typename detail::weighted_iterator_archetype::Difference<TraversalCategory>::type>
  {
    typedef WeightedIteratorArchetype<AccessCategory, TraversalCategory> me;
  public:
    WeightedIteratorArchetype(void) { is_single_pass(TraversalCategory()); }

    explicit
    WeightedIteratorArchetype(WeightedIteratorArchetype_ctor_arg arg)
    {
    }

    WeightedIteratorArchetype(const WeightedIteratorArchetype<boost::iterator_archetypes::readable_writable_iterator_t, TraversalCategory>& other)
    {}

  private:
    friend class boost::iterator_core_access;

    typename detail::weighted_iterator_archetype::Reference<AccessCategory>::type
    dereference(void) const
    { return typename detail::weighted_iterator_archetype::Reference<AccessCategory>::type(NULL, NULL); }

    // operator== is only defined if single_pass
    bool equal(const me& other) const
    { is_single_pass(TraversalCategory()); return true; }

    // increment always defined
    void increment(void) {}

    // only for bidirectional iterators
    void decrement(void)
    { is_bidirectional(TraversalCategory()); }

    // only for random access
    int distance_to(const me& other) const
    { is_random(TraversalCategory()); return 0; }

    // only for random access
    void advance(int) { is_random(TraversalCategory()); }

    void is_single_pass(boost::single_pass_traversal_tag) const {}
    void is_forward(boost::forward_traversal_tag) const {}
    void is_bidirectional(boost::bidirectional_traversal_tag) const {}
    void is_random(boost::random_access_traversal_tag) const {}
  };

}}}
#endif // end namspace theplu yat and utility