source: trunk/yat/utility/concept_check.h @ 3788

#ifndef _theplu_yat_utility_concept_check_
#define _theplu_yat_utility_concept_check_

// $Id: concept_check.h 3788 2019-01-29 06:08:25Z peter $

/*
  Copyright (C) 2010, 2011, 2013, 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/>.
*/

// always include config first
#include "config_public.h"

#include "iterator_traits.h"
#include "WeightedIteratorArchetype.h"

#include <boost/concept_archetype.hpp>
#include <boost/concept_check.hpp>
#include <boost/iterator/iterator_archetypes.hpp>
#include <boost/iterator/iterator_concepts.hpp>

namespace theplu {
namespace yat {
namespace utility {

  namespace detail {
    template<typename T>
    void avoid_compiler_warning(const T& t) {}
  }


  /**
     \brief Concept check for \ref concept_container_2d

     This class is intended to be used in a <a 
     href="\boost_url/concept_check/using_concept_check.htm">
     BOOST_CONCEPT_ASSERT </a>

     \code
     template<class T>
     void some_function(const T& t)
     {
     BOOST_CONCEPT_ASSERT((Container2D<T>));
     ...
     }
     \endcode

     \since New in yat 0.7
  */
  template <class T>
  class Container2D
  {
  public:
#ifdef YAT_HAVE_BOOST_CONCEPT_WITH_CONSTRUCTOR
    /// Default constructor
    Container2D(void) {}
#endif

    /// value_type
    typedef typename T::value_type value_type;
    /// const_reference
    typedef typename T::const_reference const_reference;
    /// const_iterator
    typedef typename T::const_iterator const_iterator;
    /// const_row_iterator
    typedef typename T::const_row_iterator const_row_iterator;
    /// const_column_iterator
    typedef typename T::const_column_iterator const_column_iterator;

    /**
       \brief function doing the concept test
     */
    BOOST_CONCEPT_USAGE(Container2D)
    {
      const_iterator iter_ = t_.begin();
      iter_ = t_.end();
      detail::avoid_compiler_warning(iter_);
      const_row_iterator row_iter_ = t_.begin_row(0);
      row_iter_ = t_.end_row(0);
      detail::avoid_compiler_warning(row_iter_);
      const_column_iterator col_iter_ = t_.begin_column(0);
      col_iter_ = t_.end_column(0);
      detail::avoid_compiler_warning(col_iter_);
      const_reference r = t_(0,0);
      value_ = r;
      size_t n = t_.rows();
      n = t_.columns();
      detail::avoid_compiler_warning(n);
      using boost_concepts::ReadableIterator;
      BOOST_CONCEPT_ASSERT((ReadableIterator<const_iterator>));
      BOOST_CONCEPT_ASSERT((ReadableIterator<const_row_iterator>));
      BOOST_CONCEPT_ASSERT((ReadableIterator<const_column_iterator>));
    }

  private:
    T t_;
    value_type value_;
  };

  /**
     \brief Concept check for \ref concept_mutable_container_2d

     This class is intended to be used in a <a 
     href="\boost_url/concept_check/using_concept_check.htm">
     BOOST_CONCEPT_ASSERT </a>

     \code
     template<class T>
     void some_function(const T& t)
     {
     BOOST_CONCEPT_ASSERT((Mutable_Container2D<T>));
     ...
     }
     \endcode

     \since New in yat 0.7
  */
  template <class T>
  class Mutable_Container2D : public Container2D<T>
  {
  public:
    /// reference
    typedef typename T::reference reference;
    /// iterator
    typedef typename T::iterator iterator;
    /// row_iterator
    typedef typename T::row_iterator row_iterator;
    /// column_iterator
    typedef typename T::column_iterator column_iterator;

    /**
       \brief function doing the concept test
     */
    BOOST_CONCEPT_USAGE(Mutable_Container2D)
    {
      iterator iter_ = t_.begin();
      iter_ = t_.end();
      detail::avoid_compiler_warning(iter_);
      row_iterator row_iter_ = t_.begin_row(0);
      row_iter_ = t_.end_row(0);
      detail::avoid_compiler_warning(row_iter_);
      column_iterator col_iter_ = t_.begin_column(0);
      col_iter_ = t_.end_column(0);
      detail::avoid_compiler_warning(col_iter_);
      reference r = t_(0,0);
      t_(0,0) = r;
      detail::avoid_compiler_warning(r);
      using boost::Mutable_RandomAccessIterator; // just to avoid long lines
      BOOST_CONCEPT_ASSERT((Mutable_RandomAccessIterator<iterator>));
      BOOST_CONCEPT_ASSERT((Mutable_RandomAccessIterator<row_iterator>));
      BOOST_CONCEPT_ASSERT((Mutable_RandomAccessIterator<column_iterator>));
    }
  private:
    T t_;
  };


  /**
     \brief Concept check for Trivial Iterator

     This class is intended to be used in a <a 
     href="\boost_url/concept_check/using_concept_check.htm">
     BOOST_CONCEPT_ASSERT </a>

     \code
     template<class Iterator>
     void some_function(const Iterator& it)
     {
     BOOST_CONCEPT_ASSERT((TrivialIterator<Iterator>));
     ...
     }
     \endcode

     \since New in yat 0.7
  */
  template <class T>
  class TrivialIterator
    : public boost::Assignable<T>
    , public boost::EqualityComparable<T>
    , public boost::DefaultConstructible<T>

  {
  public:
    /// iterator_category
    typedef typename std::iterator_traits<T>::iterator_category iterator_category;
    /// value_type
    typedef typename std::iterator_traits<T>::value_type value_type;
    /// difference_type
    typedef typename std::iterator_traits<T>::difference_type difference_type;
    /// pointer
    typedef typename std::iterator_traits<T>::pointer pointer;
    /// reference
    typedef typename std::iterator_traits<T>::reference reference;

    /**
       \brief function doing the concept test
     */
    BOOST_CONCEPT_USAGE(TrivialIterator)
    {
      T t;
      value_ = *t;
    }
  private:
    value_type value_;
  };

  /**
     \brief Concept check for \ref concept_data_iterator

     This class is intended to be used in a <a 
     href="\boost_url/concept_check/using_concept_check.htm">
     BOOST_CONCEPT_ASSERT </a>

     \code
     template<class Iterator>
     void some_function(const Iterator& it)
     {
     BOOST_CONCEPT_ASSERT((DataIteratorConcept<Iterator>));
     ...
     }
     \endcode

     \since New in yat 0.7
  */
  template <class T>
  class DataIteratorConcept
  {
  public:
    /// tag
    typedef typename weighted_iterator_traits<T>::type tag;
    /// value_type
    typedef typename std::iterator_traits<T>::value_type value_type;

    /**
       \brief function doing the concept test
     */
    BOOST_CONCEPT_USAGE(DataIteratorConcept)
    {
      BOOST_CONCEPT_ASSERT((boost_concepts::ReadableIterator<T>));
      BOOST_CONCEPT_ASSERT((boost_concepts::SinglePassIterator<T>));
      tag t;
      constraints(t);
    }
  private:
    void constraints(yat::utility::unweighted_iterator_tag t) const
    {
      BOOST_CONCEPT_ASSERT((boost::Convertible<value_type, double>));
    }

    void constraints(yat::utility::weighted_iterator_tag t) const
    {
      BOOST_CONCEPT_ASSERT((boost::Convertible<value_type, DataWeight>));
    }
  };


  /**
     \brief Concept check for a \ref concept_distance

     This class is intended to be used in a <a
     href="\boost_url/concept_check/using_concept_check.htm">
     BOOST_CONCEPT_ASSERT </a>

     \code
     template<class Distance>
     void some_function(double x)
     {
     BOOST_CONCEPT_ASSERT((DistanceConcept<Distance>));
     ...
     }
     \endcode

     \since New in yat 0.7
  */
  template <class T>
  class DistanceConcept : public boost::CopyConstructible<T>
  {
  public:
    /**
       \brief function doing the concept test
     */
    BOOST_CONCEPT_USAGE(DistanceConcept)
    {
      using boost::iterator_archetypes::readable_iterator_t;
      using boost::forward_traversal_tag;
      boost::iterator_archetype<double, readable_iterator_t,
                                forward_traversal_tag> unweighted;
      WeightedIteratorArchetype<readable_iterator_t, forward_traversal_tag>
        weighted;
      double d=0;
      d += distance_(unweighted, unweighted, unweighted);
      d += distance_(unweighted, unweighted, weighted);
      d += distance_(weighted, weighted, unweighted);
      d += distance_(weighted, weighted, weighted);
      detail::avoid_compiler_warning(d);
    }
  private:
    T distance_;
  };

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