---

more/gen/algorithm.h

Go to the documentation of this file.

//  more/algorith.h -- extensions to STL algorithm
//  Copyright (C) 1999--2001  Petter Urkedal (petter.urkedal@matfys.lth.se)

//  This file 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 2 of the License, or
//  (at your option) any later version.

//  This file 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 this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

//  As a special exception, you may use this file as part of a free
//  software library without restriction.  Specifically, if other files
//  instantiate templates or use macros or inline functions from this
//  file, or you compile this file and link it with other files to
//  produce an executable, this file does not by itself cause the
//  resulting executable to be covered by the GNU General Public
//  License.  This exception does not however invalidate any other
//  reasons why the executable file might be covered by the GNU General
//  Public License.

//  $Id: algorithm.h,v 1.1 2002/05/30 18:01:37 petter_urkedal Exp $


#ifndef MORE_GEN_ALGORITHM_H
#define MORE_GEN_ALGORITHM_H

#include <iterator>
#include <algorithm>

namespace more {
namespace gen {

  template<typename InputIterator, typename OutputIterator>
    void copy_n(InputIterator u, int n, OutputIterator v) {
        while (--n) { *u = *v; ++u; ++v; }
    }

  /*!\brief Insert an element into a sorted range.
   * \par Type requirements:
   * \a ForwardIterator is a model of Forward Iterator.
   * \pre
   * [\a first, \a{last}) is a sorted range. \a last is
   * dereferenceable.
   */
  template<typename ForwardIterator, typename T>
    inline void //ForwardIterator
    insert_sorted(ForwardIterator first, ForwardIterator last, T const x) {
        while (first != last && *first < x) ++first;
        *last = x;
        while (first != last) {
            std::iter_swap(first, last);
            ++first;
        }
        ++last;
        //return last;
        // It is more useful to return iterator to the inserted value.
    }

//   /*!\brief Remove elements from a sorted range.
//    * \par Type requirements:
//    * \a ForwardIterator is a model of Forward Iterator.
//    * \par Precondition:
//    * [\a first, \a last) is a sorted range.
//    * \return The PTE iterator of the modified range. */
//   template<typename ForwardIterator>
//     inline ForwardIterator
//     remove_sorted(ForwardIterator first, ForwardIterator last,
//                typename iterator_traits<ForwardIterator>
//                ::value_type const& x) {
//      while(first != last && *first < x) ++first;
//      ForwardIterator it = first;
//      while(first != last && !(x < *it)) ++it;
//      if(first != it)
//          return std::copy(it, last, first);
//      else return last;
//     }

  template<typename ForwardIterator0, typename ForwardIterator1, typename>
    inline bool
    counted_equal(ForwardIterator0 it0, ForwardIterator0 it0end,
                  ForwardIterator1 it1, ForwardIterator1 it1end)
    {
        for (;;) {
            if (it0 == it0end)
                return it1 == it1end;
            if (it1 == it1end)
                return false;
            if (!(*it0 == *it1))
                return false;
            ++it0;
            ++it1;
        }
    }

  template<typename ForwardIterator0, typename ForwardIterator1,
           typename Equal>
    inline bool
    counted_equal(ForwardIterator0 it0, ForwardIterator0 it0end,
                  ForwardIterator1 it1, ForwardIterator1 it1end,
                  Equal eq)
    {
        for (;;) {
            if (it0 == it0end)
                return it1 == it1end;
            if (it1 == it1end)
                return false;
            if (!eq(*it0, *it1))
                return false;
            ++it0;
            ++it1;
        }
    }

}} // more::gen

#endif

---