/usr/include/boost/heap/policies.hpp is in libboost1.65-dev 1.65.1+dfsg-0ubuntu5.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 | // boost heap
//
// Copyright (C) 2010-2011 Tim Blechmann
//
// 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)
#ifndef BOOST_HEAP_POLICIES_HPP
#define BOOST_HEAP_POLICIES_HPP
#include <boost/parameter.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/int.hpp>
#include <boost/mpl/void.hpp>
#include <boost/concept_check.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
#pragma once
#endif
namespace boost {
namespace heap {
#ifndef BOOST_DOXYGEN_INVOKED
BOOST_PARAMETER_TEMPLATE_KEYWORD(allocator)
BOOST_PARAMETER_TEMPLATE_KEYWORD(compare)
namespace tag { struct stable; }
template <bool T>
struct stable:
boost::parameter::template_keyword<tag::stable, boost::mpl::bool_<T> >
{};
namespace tag { struct mutable_; }
template <bool T>
struct mutable_:
boost::parameter::template_keyword<tag::mutable_, boost::mpl::bool_<T> >
{};
namespace tag { struct constant_time_size; }
template <bool T>
struct constant_time_size:
boost::parameter::template_keyword<tag::constant_time_size, boost::mpl::bool_<T> >
{};
namespace tag { struct store_parent_pointer; }
template <bool T>
struct store_parent_pointer:
boost::parameter::template_keyword<tag::store_parent_pointer, boost::mpl::bool_<T> >
{};
namespace tag { struct arity; }
template <unsigned int T>
struct arity:
boost::parameter::template_keyword<tag::arity, boost::mpl::int_<T> >
{};
namespace tag { struct objects_per_page; }
template <unsigned int T>
struct objects_per_page:
boost::parameter::template_keyword<tag::objects_per_page, boost::mpl::int_<T> >
{};
BOOST_PARAMETER_TEMPLATE_KEYWORD(stability_counter_type)
namespace detail {
namespace mpl = boost::mpl;
template <typename bound_args, typename tag_type>
struct has_arg
{
typedef typename boost::parameter::binding<bound_args, tag_type, mpl::void_>::type type;
static const bool value = mpl::is_not_void_<type>::type::value;
};
template <typename bound_args>
struct extract_stable
{
static const bool has_stable = has_arg<bound_args, tag::stable>::value;
typedef typename mpl::if_c<has_stable,
typename has_arg<bound_args, tag::stable>::type,
mpl::bool_<false>
>::type stable_t;
static const bool value = stable_t::value;
};
template <typename bound_args>
struct extract_mutable
{
static const bool has_mutable = has_arg<bound_args, tag::mutable_>::value;
typedef typename mpl::if_c<has_mutable,
typename has_arg<bound_args, tag::mutable_>::type,
mpl::bool_<false>
>::type mutable_t;
static const bool value = mutable_t::value;
};
}
#else
/** \brief Specifies the predicate for the heap order
*/
template <typename T>
struct compare{};
/** \brief Configure heap as mutable
*
* Certain heaps need to be configured specifically do be mutable.
*
* */
template <bool T>
struct mutable_{};
/** \brief Specifies allocator for the internal memory management
*/
template <typename T>
struct allocator{};
/** \brief Configure a heap as \b stable
*
* A priority queue is stable, if elements with the same priority are popped from the heap, in the same order as
* they are inserted.
* */
template <bool T>
struct stable{};
/** \brief Specifies the type for stability counter
*
* */
template <typename IntType>
struct stability_counter_type{};
/** \brief Configures complexity of <tt> size() </tt>
*
* Specifies, whether size() should have linear or constant complexity.
* */
template <bool T>
struct constant_time_size{};
/** \brief Store parent pointer in heap node.
*
* Maintaining a parent pointer adds some maintenance and size overhead, but iterating a heap is more efficient.
* */
template <bool T>
struct store_parent_pointer{};
/** \brief Specify arity.
*
* Specifies the arity of a D-ary heap
* */
template <unsigned int T>
struct arity{};
#endif
} /* namespace heap */
} /* namespace boost */
#endif /* BOOST_HEAP_POLICIES_HPP */
|