concept_check.h

#ifndef _theplu_yat_utility_concept_check_
#define _theplu_yat_utility_concept_check_

// $Id: concept_check.h 3569 2017-01-09 03:43:08Z 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 {

  template <class T>
  class Container2D
  {
  public:
#ifdef YAT_HAVE_BOOST_CONCEPT_WITH_CONSTRUCTOR
    Container2D(void) {}
#endif

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

    BOOST_CONCEPT_USAGE(Container2D)
    {
      const_iterator iter_ = t_.begin();
      iter_ = t_.end();
      const_row_iterator row_iter_ = t_.begin_row(0);
      row_iter_ = t_.end_row(0);
      const_column_iterator col_iter_ = t_.begin_column(0);
      col_iter_ = t_.end_column(0);
      const_reference r = t_(0,0);
      value_ = r;
      size_t n = t_.rows();
      n = t_.columns();
      some_func(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:
    void some_func(size_t x) const {}
    T t_;
    value_type value_;
  };

  template <class T>
  class Mutable_Container2D : public Container2D<T>
  {
  public:
    typedef typename T::reference reference;
    typedef typename T::iterator iterator;
    typedef typename T::row_iterator row_iterator;
    typedef typename T::column_iterator column_iterator;

    BOOST_CONCEPT_USAGE(Mutable_Container2D)
    {
      iterator iter_ = t_.begin();
      iter_ = t_.end();
      row_iterator row_iter_ = t_.begin_row(0);
      row_iter_ = t_.end_row(0);
      column_iterator col_iter_ = t_.begin_column(0);
      col_iter_ = t_.end_column(0);
      reference r = t_(0,0);
      t_(0,0) = 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_;
  };


  template <class T>
  class TrivialIterator
    : public boost::Assignable<T>
    , public boost::EqualityComparable<T>
    , public boost::DefaultConstructible<T>

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

    BOOST_CONCEPT_USAGE(TrivialIterator)
    {
      T t;
      value_ = *t;
    }
  private:
    value_type value_;
  };

  template <class T>
  class DataIteratorConcept
  {
  public:
    typedef typename weighted_iterator_traits<T>::type tag;
    typedef typename std::iterator_traits<T>::value_type value_type;

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


  template <class T>
  class DistanceConcept : public boost::CopyConstructible<T>
  {
  public:
    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);
      // avoid compiler warning
      func(d);
    }
  private:
    void func(double x) {}
    T distance_;
  };

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