FM / detail

/usr/include/boost/detail

Name	Size	Mode	Actions
winapi/	-	0755	rm
algorithm.hpp	2898	0644	edit dl rm
allocator_utilities.hpp	4790	0644	edit dl rm
atomic_count.hpp	618	0644	edit dl rm
basic_pointerbuf.hpp	4469	0644	edit dl rm
binary_search.hpp	6239	0644	edit dl rm
bitmask.hpp	3033	0644	edit dl rm
call_traits.hpp	4324	0644	edit dl rm
catch_exceptions.hpp	5677	0644	edit dl rm
compressed_pair.hpp	17002	0644	edit dl rm
container_fwd.hpp	5160	0644	edit dl rm
fenv.hpp	3206	0644	edit dl rm
has_default_constructor.hpp	935	0644	edit dl rm
identifier.hpp	3178	0644	edit dl rm
indirect_traits.hpp	4423	0644	edit dl rm
interlocked.hpp	14258	0644	edit dl rm
is_incrementable.hpp	3071	0644	edit dl rm
is_sorted.hpp	1432	0644	edit dl rm
is_xxx.hpp	1250	0644	edit dl rm
iterator.hpp	1146	0644	edit dl rm
lcast_precision.hpp	6089	0644	edit dl rm
lightweight_main.hpp	1226	0644	edit dl rm
lightweight_mutex.hpp	630	0644	edit dl rm
lightweight_test.hpp	436	0644	edit dl rm
lightweight_test_report.hpp	2223	0644	edit dl rm
lightweight_thread.hpp	811	0644	edit dl rm
named_template_params.hpp	6124	0644	edit dl rm
no_exceptions_support.hpp	570	0644	edit dl rm
numeric_traits.hpp	5490	0644	edit dl rm
ob_compressed_pair.hpp	16399	0644	edit dl rm
quick_allocator.hpp	606	0644	edit dl rm
reference_content.hpp	2443	0644	edit dl rm
scoped_enum_emulation.hpp	541	0644	edit dl rm
select_type.hpp	1130	0644	edit dl rm
sp_typeinfo.hpp	857	0644	edit dl rm
templated_streams.hpp	2242	0644	edit dl rm
utf8_codecvt_facet.hpp	7745	0644	edit dl rm
utf8_codecvt_facet.ipp	9578	0644	edit dl rm
workaround.hpp	335	0644	edit dl rm

Edit: /usr/include/boost/detail/binary_search.hpp (6239B)

# include <utility>
# include <iterator>

namespace boost { namespace detail {

template <class ForwardIter, class Tp>
ForwardIter lower_bound(ForwardIter first, ForwardIter last,
                             const Tp& val)
{
    typedef std::iterator_traits<ForwardIter> traits;

typename traits::difference_type len = std::distance(first, last);
    typename traits::difference_type half;
    ForwardIter middle;

while (len > 0) {
      half = len >> 1;
      middle = first;
      std::advance(middle, half);
      if (*middle < val) {
        first = middle;
        ++first;
        len = len - half - 1;
      }
      else
        len = half;
    }
    return first;
}

template <class ForwardIter, class Tp, class Compare>
ForwardIter lower_bound(ForwardIter first, ForwardIter last,
                              const Tp& val, Compare comp)
{
  typedef std::iterator_traits<ForwardIter> traits;

typename traits::difference_type len = std::distance(first, last);
  typename traits::difference_type half;
  ForwardIter middle;

while (len > 0) {
    half = len >> 1;
    middle = first;
    std::advance(middle, half);
    if (comp(*middle, val)) {
      first = middle;
      ++first;
      len = len - half - 1;
    }
    else
      len = half;
  }
  return first;
}

template <class ForwardIter, class Tp>
ForwardIter upper_bound(ForwardIter first, ForwardIter last,
                           const Tp& val)
{
  typedef std::iterator_traits<ForwardIter> traits;

typename traits::difference_type len = std::distance(first, last);
  typename traits::difference_type half;
  ForwardIter middle;

while (len > 0) {
    half = len >> 1;
    middle = first;
    std::advance(middle, half);
    if (val < *middle)
      len = half;
    else {
      first = middle;
      ++first;
      len = len - half - 1;
    }
  }
  return first;
}

template <class ForwardIter, class Tp, class Compare>
ForwardIter upper_bound(ForwardIter first, ForwardIter last,
                           const Tp& val, Compare comp)
{
  typedef std::iterator_traits<ForwardIter> traits;

typename traits::difference_type len = std::distance(first, last);
  typename traits::difference_type half;
  ForwardIter middle;

while (len > 0) {
    half = len >> 1;
    middle = first;
    std::advance(middle, half);
    if (comp(val, *middle))
      len = half;
    else {
      first = middle;
      ++first;
      len = len - half - 1;
    }
  }
  return first;
}

template <class ForwardIter, class Tp>
std::pair<ForwardIter, ForwardIter>
equal_range(ForwardIter first, ForwardIter last, const Tp& val)
{
  typedef std::iterator_traits<ForwardIter> traits;

typename traits::difference_type len = std::distance(first, last);
  typename traits::difference_type half;
  ForwardIter middle, left, right;

while (len > 0) {
    half = len >> 1;
    middle = first;
    std::advance(middle, half);
    if (*middle < val) {
      first = middle;
      ++first;
      len = len - half - 1;
    }
    else if (val < *middle)
      len = half;
    else {
      left = boost::detail::lower_bound(first, middle, val);
      std::advance(first, len);
      right = boost::detail::upper_bound(++middle, first, val);
      return std::pair<ForwardIter, ForwardIter>(left, right);
    }
  }
  return std::pair<ForwardIter, ForwardIter>(first, first);
}

template <class ForwardIter, class Tp, class Compare>
std::pair<ForwardIter, ForwardIter>
equal_range(ForwardIter first, ForwardIter last, const Tp& val,
              Compare comp)
{
  typedef std::iterator_traits<ForwardIter> traits;

typename traits::difference_type len = std::distance(first, last);
  typename traits::difference_type half;
  ForwardIter middle, left, right;

while (len > 0) {
    half = len >> 1;
    middle = first;
    std::advance(middle, half);
    if (comp(*middle, val)) {
      first = middle;
      ++first;
      len = len - half - 1;
    }
    else if (comp(val, *middle))
      len = half;
    else {
      left = boost::detail::lower_bound(first, middle, val, comp);
      std::advance(first, len);
      right = boost::detail::upper_bound(++middle, first, val, comp);
      return std::pair<ForwardIter, ForwardIter>(left, right);
    }
  }
  return std::pair<ForwardIter, ForwardIter>(first, first);
}

template <class ForwardIter, class Tp>
bool binary_search(ForwardIter first, ForwardIter last,
                   const Tp& val) {
  ForwardIter i = boost::detail::lower_bound(first, last, val);
  return i != last && !(val < *i);
}

template <class ForwardIter, class Tp, class Compare>
bool binary_search(ForwardIter first, ForwardIter last,
                   const Tp& val,
                   Compare comp) {
  ForwardIter i = boost::detail::lower_bound(first, last, val, comp);
  return i != last && !comp(val, *i);
}

}} // namespace boost::detail

#endif // BINARY_SEARCH_DWA_122600_H_

// Copyright (c) 2000 David Abrahams. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Copyright (c) 1994 // Hewlett-Packard Company // // Permission to use, copy, modify, distribute and sell this software // and its documentation for any purpose is hereby granted without fee, // provided that the above copyright notice appear in all copies and // that both that copyright notice and this permission notice appear // in supporting documentation. Hewlett-Packard Company makes no // representations about the suitability of this software for any // purpose. It is provided "as is" without express or implied warranty. // // Copyright (c) 1996 // Silicon Graphics Computer Systems, Inc. // // Permission to use, copy, modify, distribute and sell this software // and its documentation for any purpose is hereby granted without fee, // provided that the above copyright notice appear in all copies and // that both that copyright notice and this permission notice appear // in supporting documentation. Silicon Graphics makes no // representations about the suitability of this software for any // purpose. It is provided "as is" without express or implied warranty. // #ifndef BINARY_SEARCH_DWA_122600_H_ # define BINARY_SEARCH_DWA_122600_H_ # include # include namespace boost { namespace detail { template ForwardIter lower_bound(ForwardIter first, ForwardIter last, const Tp& val) { typedef std::iterator_traits traits; typename traits::difference_type len = std::distance(first, last); typename traits::difference_type half; ForwardIter middle; while (len > 0) { half = len >> 1; middle = first; std::advance(middle, half); if (*middle < val) { first = middle; ++first; len = len - half - 1; } else len = half; } return first; } template ForwardIter lower_bound(ForwardIter first, ForwardIter last, const Tp& val, Compare comp) { typedef std::iterator_traits traits; typename traits::difference_type len = std::distance(first, last); typename traits::difference_type half; ForwardIter middle; while (len > 0) { half = len >> 1; middle = first; std::advance(middle, half); if (comp(*middle, val)) { first = middle; ++first; len = len - half - 1; } else len = half; } return first; } template ForwardIter upper_bound(ForwardIter first, ForwardIter last, const Tp& val) { typedef std::iterator_traits traits; typename traits::difference_type len = std::distance(first, last); typename traits::difference_type half; ForwardIter middle; while (len > 0) { half = len >> 1; middle = first; std::advance(middle, half); if (val < *middle) len = half; else { first = middle; ++first; len = len - half - 1; } } return first; } template ForwardIter upper_bound(ForwardIter first, ForwardIter last, const Tp& val, Compare comp) { typedef std::iterator_traits traits; typename traits::difference_type len = std::distance(first, last); typename traits::difference_type half; ForwardIter middle; while (len > 0) { half = len >> 1; middle = first; std::advance(middle, half); if (comp(val, *middle)) len = half; else { first = middle; ++first; len = len - half - 1; } } return first; } template std::pair equal_range(ForwardIter first, ForwardIter last, const Tp& val) { typedef std::iterator_traits traits; typename traits::difference_type len = std::distance(first, last); typename traits::difference_type half; ForwardIter middle, left, right; while (len > 0) { half = len >> 1; middle = first; std::advance(middle, half); if (*middle < val) { first = middle; ++first; len = len - half - 1; } else if (val < *middle) len = half; else { left = boost::detail::lower_bound(first, middle, val); std::advance(first, len); right = boost::detail::upper_bound(++middle, first, val); return std::pair(left, right); } } return std::pair(first, first); } template std::pair equal_range(ForwardIter first, ForwardIter last, const Tp& val, Compare comp) { typedef std::iterator_traits traits; typename traits::difference_type len = std::distance(first, last); typename traits::difference_type half; ForwardIter middle, left, right; while (len > 0) { half = len >> 1; middle = first; std::advance(middle, half); if (comp(*middle, val)) { first = middle; ++first; len = len - half - 1; } else if (comp(val, *middle)) len = half; else { left = boost::detail::lower_bound(first, middle, val, comp); std::advance(first, len); right = boost::detail::upper_bound(++middle, first, val, comp); return std::pair(left, right); } } return std::pair(first, first); } template bool binary_search(ForwardIter first, ForwardIter last, const Tp& val) { ForwardIter i = boost::detail::lower_bound(first, last, val); return i != last && !(val < *i); } template bool binary_search(ForwardIter first, ForwardIter last, const Tp& val, Compare comp) { ForwardIter i = boost::detail::lower_bound(first, last, val, comp); return i != last && !comp(val, *i); } }} // namespace boost::detail #endif // BINARY_SEARCH_DWA_122600_H_