source: trunk/test/weighted_iterator_archetype.h @ 3379

#ifndef _theplu_yat_test_weighted_iterator_archetype
#define _theplu_yat_test_weighted_iterator_archetype

// $Id: weighted_iterator_archetype.h 3379 2015-02-13 11:22:36Z peter $

/*
  Copyright (C) 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 <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 test {

  // argument to iterators that are not default constructible
  struct ctor_arg {};

  // perhaps the stuff below should live in its own namespace, since
  // no one is really expected to use these classes other than the
  // weighted_iterator_archetype class below.

  struct bogus {};

  template<class AccessCategory> struct Reference {};

  template<>
  struct Reference<boost::iterator_archetypes::readable_iterator_t>
  {
    typedef const utility::DataWeightProxy<const double*, const double*> type;
  };


  template<>
  struct Reference<boost::iterator_archetypes::readable_writable_iterator_t>
  {
    typedef utility::DataWeightProxy<double*, double*> type;
  };

  template<class TraversalCategory> struct Difference {};

  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; };


  /*
    The purpose of this class is to complement
    boost::iterator_archetype, which doesn't work well when the
    value_type is DataWeight (weighted iterator) and reference is not
    DataWeight&. In that case boost::iterator_archetype creates a
    proxy class that doesn't work well with yat's machinery to detect
    whether an iterator is weighted or not. Instead we should use this
    class below for testing. It returns DataWeightProxy from operator*
    and works as intended.

    Template arguments:

    AccessCategory: either
    boost::iterator_archetypes::readable_iterator_t
    (for const iterator) or
    boost::iterator_archetypes::readable_writable_iterator_t
    (for mutable iterator)

    Only writable iterators are not allowed because a weighted
    iterator must be readable in order to ensure that value_type is
    defined.

    TraversalCategory is one of the boost categories:
    // currently not working boost::incrementable_traversal_tag
    boost::single_pass_traversal_tag
    boost::forward_traversal_tag
    boost::bidirectional_traversal_tag
    boost::random_access_traversal_tag
   */
  template<typename AccessCategory, typename TraversalCategory>
  class weighted_iterator_archetype
    : public boost::iterator_facade<
    weighted_iterator_archetype<AccessCategory, TraversalCategory>
    , utility::DataWeight
    , TraversalCategory
    , typename Reference<AccessCategory>::type
    , typename Difference<TraversalCategory>::type>
  {
    typedef weighted_iterator_archetype<AccessCategory, TraversalCategory> me;
  public:
    // constructors
    weighted_iterator_archetype(void) { is_forward(TraversalCategory()); }
    weighted_iterator_archetype(ctor_arg arg)
    {
      // Category incrementable_traversal_tag is problematic on
      // certain systems, so avoid usage.
      is_single_pass(TraversalCategory());
    }

    // Create an iterator from a mutable iterator, i.e., this is a
    // copy constructor if if mutable, otherwise conversion from
    // mutable to const iterator.
    weighted_iterator_archetype(const weighted_iterator_archetype<boost::iterator_archetypes::readable_writable_iterator_t, TraversalCategory>& other)
    {}

  private:
    friend class boost::iterator_core_access;

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

    bool equal(const me& other) const
    { is_single_pass(TraversalCategory()); return true; }
    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; }

    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