<h2>Editing File: /usr/include/c++/8/parallel/for_each_selectors.h</h2><form method='post'><textarea name='content' class='file-edit'>// -*- C++ -*-

// Copyright (C) 2007-2018 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This 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, or (at your option) any later
// version.

// This 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.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// &lt;http://www.gnu.org/licenses/&gt;.

/** @file parallel/for_each_selectors.h
 *  @brief Functors representing different tasks to be plugged into the
 *  generic parallelization methods for embarrassingly parallel functions.
 *  This file is a GNU parallel extension to the Standard C++ Library.
 */

// Written by Felix Putze.

#ifndef _GLIBCXX_PARALLEL_FOR_EACH_SELECTORS_H
#define _GLIBCXX_PARALLEL_FOR_EACH_SELECTORS_H 1

#include &lt;parallel/basic_iterator.h&gt;

namespace __gnu_parallel
{
  /** @brief Generic __selector for embarrassingly parallel functions. */
  template&lt;typename _It&gt;
    struct __generic_for_each_selector
    {
      /** @brief _Iterator on last element processed; needed for some
       *  algorithms (e. g. std::transform()).
       */
      _It _M_finish_iterator;
    };

  /** @brief std::for_each() selector. */
  template&lt;typename _It&gt;
    struct __for_each_selector : public __generic_for_each_selector&lt;_It&gt;
    {
      /** @brief Functor execution.
       *  @param __o Operator.
       *  @param __i iterator referencing object. */
      template&lt;typename _Op&gt;
        bool
        operator()(_Op&amp; __o, _It __i)
        {
          __o(*__i);
          return true;
        }
    };

  /** @brief std::generate() selector. */
  template&lt;typename _It&gt;
    struct __generate_selector : public __generic_for_each_selector&lt;_It&gt;
    {
      /** @brief Functor execution.
       *  @param __o Operator.
       *  @param __i iterator referencing object. */
      template&lt;typename _Op&gt;
        bool
        operator()(_Op&amp; __o, _It __i)
        {
          *__i = __o();
          return true;
        }
    };

  /** @brief std::fill() selector. */
  template&lt;typename _It&gt;
    struct __fill_selector : public __generic_for_each_selector&lt;_It&gt;
    {
      /** @brief Functor execution.
       *  @param __v Current value.
       *  @param __i iterator referencing object. */
      template&lt;typename _ValueType&gt;
        bool
        operator()(_ValueType&amp; __v, _It __i)
        {
          *__i = __v;
          return true;
        }
    };

  /** @brief std::transform() __selector, one input sequence variant. */
  template&lt;typename _It&gt;
    struct __transform1_selector : public __generic_for_each_selector&lt;_It&gt;
    {
      /** @brief Functor execution.
       *  @param __o Operator.
       *  @param __i iterator referencing object. */
      template&lt;typename _Op&gt;
        bool
        operator()(_Op&amp; __o, _It __i)
        {
          *__i.second = __o(*__i.first);
          return true;
        }
    };

  /** @brief std::transform() __selector, two input sequences variant. */
  template&lt;typename _It&gt;
    struct __transform2_selector : public __generic_for_each_selector&lt;_It&gt;
    {
      /** @brief Functor execution.
       *  @param __o Operator.
       *  @param __i iterator referencing object. */
      template&lt;typename _Op&gt;
        bool
        operator()(_Op&amp; __o, _It __i)
        {
          *__i._M_third = __o(*__i._M_first, *__i._M_second);
          return true;
        }
    };

  /** @brief std::replace() selector. */
  template&lt;typename _It, typename _Tp&gt;
    struct __replace_selector : public __generic_for_each_selector&lt;_It&gt;
    {
      /** @brief Value to replace with. */
      const _Tp&amp; __new_val;

      /** @brief Constructor
       *  @param __new_val Value to replace with. */
      explicit
      __replace_selector(const _Tp &amp;__new_val) : __new_val(__new_val) {}

      /** @brief Functor execution.
       *  @param __v Current value.
       *  @param __i iterator referencing object. */
      bool
      operator()(_Tp&amp; __v, _It __i)
      {
        if (*__i == __v)
          *__i = __new_val;
        return true;
      }
    };

  /** @brief std::replace() selector. */
  template&lt;typename _It, typename _Op, typename _Tp&gt;
    struct __replace_if_selector : public __generic_for_each_selector&lt;_It&gt;
    {
      /** @brief Value to replace with. */
      const _Tp&amp; __new_val;

      /** @brief Constructor.
       *  @param __new_val Value to replace with. */
      explicit
      __replace_if_selector(const _Tp &amp;__new_val) : __new_val(__new_val) { }

      /** @brief Functor execution.
       *  @param __o Operator.
       *  @param __i iterator referencing object. */
      bool
      operator()(_Op&amp; __o, _It __i)
      {
        if (__o(*__i))
          *__i = __new_val;
        return true;
      }
    };

  /** @brief std::count() selector. */
  template&lt;typename _It, typename _Diff&gt;
    struct __count_selector : public __generic_for_each_selector&lt;_It&gt;
    {
      /** @brief Functor execution.
       *  @param __v Current value.
       *  @param __i iterator referencing object.
       *  @return 1 if count, 0 if does not count. */
      template&lt;typename _ValueType&gt;
        _Diff
        operator()(_ValueType&amp; __v, _It __i)
        { return (__v == *__i) ? 1 : 0; }
    };

  /** @brief std::count_if () selector. */
  template&lt;typename _It, typename _Diff&gt;
    struct __count_if_selector : public __generic_for_each_selector&lt;_It&gt;
    {
      /** @brief Functor execution.
       *  @param __o Operator.
       *  @param __i iterator referencing object.
       *  @return 1 if count, 0 if does not count. */
      template&lt;typename _Op&gt;
        _Diff
        operator()(_Op&amp; __o, _It __i)
        { return (__o(*__i)) ? 1 : 0; }
    };

  /** @brief std::accumulate() selector. */
  template&lt;typename _It&gt;
    struct __accumulate_selector : public __generic_for_each_selector&lt;_It&gt;
    {
      /** @brief Functor execution.
       *  @param __o Operator (unused).
       *  @param __i iterator referencing object.
       *  @return The current value. */
      template&lt;typename _Op&gt;
        typename std::iterator_traits&lt;_It&gt;::value_type
        operator()(_Op __o, _It __i)
        { return *__i; }
    };

  /** @brief std::inner_product() selector. */
  template&lt;typename _It, typename _It2, typename _Tp&gt;
    struct __inner_product_selector : public __generic_for_each_selector&lt;_It&gt;
    {
      /** @brief Begin iterator of first sequence. */
      _It  __begin1_iterator;

      /** @brief Begin iterator of second sequence. */
      _It2 __begin2_iterator;

      /** @brief Constructor.
       *  @param __b1 Begin iterator of first sequence.
       *  @param __b2 Begin iterator of second sequence. */
      explicit
      __inner_product_selector(_It __b1, _It2 __b2)
      : __begin1_iterator(__b1), __begin2_iterator(__b2) { }

      /** @brief Functor execution.
       *  @param __mult Multiplication functor.
       *  @param __current iterator referencing object.
       *  @return Inner product elemental __result. */
      template&lt;typename _Op&gt;
        _Tp
        operator()(_Op __mult, _It __current)
        {
          typename std::iterator_traits&lt;_It&gt;::difference_type __position
            = __current - __begin1_iterator;
          return __mult(*__current, *(__begin2_iterator + __position));
        }
    };

  /** @brief Selector that just returns the passed iterator. */
  template&lt;typename _It&gt;
    struct __identity_selector : public __generic_for_each_selector&lt;_It&gt;
    {
      /** @brief Functor execution.
       *  @param __o Operator (unused).
       *  @param __i iterator referencing object.
       *  @return Passed iterator. */
      template&lt;typename _Op&gt;
        _It
        operator()(_Op __o, _It __i)
        { return __i; }
    };

  /** @brief Selector that returns the difference between two adjacent
   *  __elements.
   */
  template&lt;typename _It&gt;
    struct __adjacent_difference_selector
    : public __generic_for_each_selector&lt;_It&gt;
    {
      template&lt;typename _Op&gt;
        bool
        operator()(_Op&amp; __o, _It __i)
        {
          typename _It::first_type __go_back_one = __i.first;
          --__go_back_one;
          *__i.second = __o(*__i.first, *__go_back_one);
          return true;
        }
    };

  /** @brief Functor doing nothing
   *
   *  For some __reduction tasks (this is not a function object, but is
   *  passed as __selector __dummy parameter.
   */
  struct _Nothing
  {
    /** @brief Functor execution.
     *  @param __i iterator referencing object. */
    template&lt;typename _It&gt;
      void
      operator()(_It __i) { }
  };

  /** @brief Reduction function doing nothing. */
  struct _DummyReduct
  {
    bool
    operator()(bool, bool) const
    { return true; }
  };

  /** @brief Reduction for finding the maximum element, using a comparator. */
  template&lt;typename _Compare, typename _It&gt;
    struct __min_element_reduct
    {
      _Compare&amp; __comp;

      explicit
      __min_element_reduct(_Compare &amp;__c) : __comp(__c) { }

      _It
      operator()(_It __x, _It __y)
      { return (__comp(*__x, *__y)) ? __x : __y; }
    };

  /** @brief Reduction for finding the maximum element, using a comparator. */
  template&lt;typename _Compare, typename _It&gt;
    struct __max_element_reduct
    {
      _Compare&amp; __comp;

      explicit
      __max_element_reduct(_Compare&amp; __c) : __comp(__c) { }

      _It
      operator()(_It __x, _It __y)
      { return (__comp(*__x, *__y)) ? __y : __x; }
    };

  /** @brief General reduction, using a binary operator. */
  template&lt;typename _BinOp&gt;
    struct __accumulate_binop_reduct
    {
      _BinOp&amp; __binop;

      explicit
      __accumulate_binop_reduct(_BinOp&amp; __b) : __binop(__b) { }

      template&lt;typename _Result, typename _Addend&gt;
        _Result
        operator()(const _Result&amp; __x, const _Addend&amp; __y)
        { return __binop(__x, __y); }
    };
}

#endif /* _GLIBCXX_PARALLEL_FOR_EACH_SELECTORS_H */
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Finclude%2Fc%2B%2B%2F8%2Fparallel'>Back to Directory</a>