|
template<typename InputRange , typename T > |
T | accumulate (const InputRange &range, T init) |
|
template<typename InputIterator , typename T , typename BinaryOperation > |
T | accumulate (InputIterator first, InputIterator last, T init, BinaryOperation binary_op) |
|
template<typename InputRange , typename T , typename BinaryOperation > |
T | accumulate (const InputRange &range, T init, BinaryOperation binary_op) |
|
template<typename I , typename Op > |
std::iterator_traits< I >::value_type | add_to_counter (I f, I l, Op op, ADOBE_VALUE_TYPE(I) x, ADOBE_VALUE_TYPE(I) z=adobe::identity_element< Op >()()) |
|
template<typename InputRange , typename OutputIterator > |
OutputIterator | adjacent_difference (const InputRange &range, OutputIterator result) |
|
template<typename InputIterator , typename OutputIterator , typename BinaryOperation > |
OutputIterator | adjacent_difference (InputIterator first, InputIterator last, OutputIterator result, BinaryOperation binary_op) |
|
template<typename InputRange , typename OutputIterator , typename BinaryOperation > |
OutputIterator | adjacent_difference (const InputRange &range, OutputIterator result, BinaryOperation binary_op) |
|
template<class ForwardRange > |
boost::range_iterator< ForwardRange >::type | adjacent_find (ForwardRange &range) |
|
template<class ForwardRange > |
boost::range_const_iterator< ForwardRange >::type | adjacent_find (const ForwardRange &range) |
|
template<class ForwardIterator , class BinaryPredicate > |
ForwardIterator | adjacent_find (ForwardIterator first, ForwardIterator last, BinaryPredicate pred) |
|
template<class ForwardRange , class BinaryPredicate > |
boost::range_iterator< ForwardRange >::type | adjacent_find (ForwardRange &range, BinaryPredicate pred) |
|
template<class ForwardRange , class BinaryPredicate > |
boost::range_const_iterator< ForwardRange >::type | adjacent_find (const ForwardRange &range, BinaryPredicate pred) |
|
void | apply_layout_parameters (layout_attributes_t &data, const dictionary_t ¶meters) |
|
template<typename T > |
T | arbitrary_regular_value () |
|
template<typename C > |
back_move_iterator< C > | back_mover (C &x) |
|
format_base::stream_type & | begin_alternate (format_base::stream_type &os) |
|
std::ostream & | begin_asl_cel (std::ostream &os) |
|
std::ostream & | begin_asl_cel_unsafe (std::ostream &os) |
|
format_base::stream_type & | begin_format (format_base::stream_type &os) |
|
std::ostream & | begin_javascript (std::ostream &os) |
|
std::ostream & | begin_pdf (std::ostream &os) |
|
format_base::stream_type & | begin_sequence (format_base::stream_type &os) |
|
std::ostream & | begin_xml (std::ostream &os) |
|
template<typename I , typename T , typename C , typename P > |
I | binary_search (I f, I l, const T &x, C c, P p) |
|
template<typename I , typename T , typename C > |
I | binary_search (I f, I l, const T &x, C c) |
|
template<typename I , typename T > |
I | binary_search (I f, I l, const T &x) |
|
template<typename I , typename T > |
boost::range_iterator< I >::type | binary_search (I &range, const T &x) |
|
template<typename I , typename T > |
boost::range_const_iterator< I >::type | binary_search (const I &range, const T &x) |
|
template<typename I , typename T , typename C > |
boost::range_iterator< I >::type | binary_search (I &range, const T &x, C c) |
|
template<typename I , typename T , typename C > |
boost::range_const_iterator< I >::type | binary_search (const I &range, const T &x, C c) |
|
template<typename I , typename T , typename C , typename P > |
boost::lazy_disable_if< boost::is_same< I, T >, boost::range_iterator< I > >::type | binary_search (I &r, const T &x, C c, P p) |
|
template<typename I , typename T , typename C , typename P > |
boost::lazy_disable_if< boost::is_same< I, T >, boost::range_const_iterator< I > >::type | binary_search (const I &r, const T &x, C c, P p) |
|
eve_callback_suite_t | bind_layout (const bind_layout_proc_t &proc, sheet_t &layout_sheet, virtual_machine_t &evaluator) |
|
adam_callback_suite_t | bind_to_sheet (sheet_t &) |
|
adam_callback_suite_t | bind_to_sheet (sheet_t &, external_model_t &) |
|
| BOOST_STATIC_ASSERT (!(sizeof(intptr_t)< sizeof(void *))) |
|
| BOOST_STATIC_ASSERT (!(sizeof(uintptr_t)< sizeof(void *))) |
|
| BOOST_STATIC_ASSERT (sizeof(closed_hash_set< int >)==sizeof(void *)) |
|
| BOOST_TEST_CASE_TEMPLATE_FUNCTION (check_regulars, T) |
|
int | bottom (const place_data_t &place_data) |
|
template<typename I1 , typename I2 , typename BP > |
bool | bounded_equal (I1 first1, I1 last1, I2 first2, I2 last2, BP pred) |
|
template<typename I1 , typename I2 > |
bool | bounded_equal (I1 first1, I1 last1, I2 first2, I2 last2) |
|
template<typename R1 , typename R2 > |
bool | bounded_equal (R1 &range1, R2 &range2) |
|
template<class T , typename F , typename Dictionary , typename SingleArg > |
arg_stream::result_type< F >::type | call_member_with_dictionary (T *that, F f, Dictionary const &dict, SingleArg const &key_or_key_range) |
|
template<class T , typename F , typename Dictionary , typename SingleArg > |
arg_stream::result_type< F >::type | call_member_with_dictionary (T *that, F f, std::nothrow_t, Dictionary const &dict, SingleArg const &key_or_key_range) |
|
template<typename X , typename F , typename Dictionary , typename T1 , typename T2 > |
arg_stream::result_type< F >::type | call_member_with_dictionary (X &x, F f, Dictionary const &dict, T1 const &key1, T2 const &key2) |
|
template<typename X , typename F , typename Dictionary , typename T1 , typename T2 > |
arg_stream::result_type< F >::type | call_member_with_dictionary (X x, F f, std::nothrow_t, Dictionary const &dict, T1 const &key1, T2 const &key2) |
|
template<typename X , typename F , typename Dictionary , typename T1 , typename T2 , typename T3 > |
arg_stream::result_type< F >::type | call_member_with_dictionary (X &x, F f, Dictionary const &dict, T1 const &key1, T2 const &key2, T3 const &key3) |
|
template<typename X , typename F , typename Dictionary , typename T1 , typename T2 , typename T3 > |
arg_stream::result_type< F >::type | call_member_with_dictionary (X x, F f, std::nothrow_t, Dictionary const &dict, T1 const &key1, T2 const &key2, T3 const &key3) |
|
template<typename X , typename F , typename Dictionary , typename T1 , typename T2 , typename T3 , typename T4 > |
arg_stream::result_type< F >::type | call_member_with_dictionary (X &x, F f, Dictionary const &dict, T1 const &key1, T2 const &key2, T3 const &key3, T4 const &key4) |
|
template<typename X , typename F , typename Dictionary , typename T1 , typename T2 , typename T3 , typename T4 > |
arg_stream::result_type< F >::type | call_member_with_dictionary (X x, F f, std::nothrow_t, Dictionary const &dict, T1 const &key1, T2 const &key2, T3 const &key3, T4 const &key4) |
|
void | call_once (void(*func)(), adobe::once_flag &flag) |
|
template<typename F , typename Dictionary , typename SingleArg > |
arg_stream::result_type< F >::type | call_with_dictionary (F f, Dictionary const &dict, SingleArg const &key_or_key_range) |
|
template<typename F , typename Dictionary , typename SingleArg > |
arg_stream::result_type< F >::type | call_with_dictionary (F f, std::nothrow_t, Dictionary const &dict, SingleArg const &key_or_key_range) |
|
template<typename F , typename Dictionary , typename T1 , typename T2 > |
arg_stream::result_type< F >::type | call_with_dictionary (F f, Dictionary const &dict, T1 const &key1, T2 const &key2) |
|
template<typename F , typename Dictionary , typename T1 , typename T2 > |
arg_stream::result_type< F >::type | call_with_dictionary (F f, std::nothrow_t, Dictionary const &dict, T1 const &key1, T2 const &key2) |
|
template<typename F , typename Dictionary , typename T1 , typename T2 , typename T3 > |
arg_stream::result_type< F >::type | call_with_dictionary (F f, Dictionary const &dict, T1 const &key1, T2 const &key2, T3 const &key3) |
|
template<typename F , typename Dictionary , typename T1 , typename T2 , typename T3 > |
arg_stream::result_type< F >::type | call_with_dictionary (F f, std::nothrow_t, Dictionary const &dict, T1 const &key1, T2 const &key2, T3 const &key3) |
|
template<typename F , typename Dictionary , typename T1 , typename T2 , typename T3 , typename T4 > |
arg_stream::result_type< F >::type | call_with_dictionary (F f, Dictionary const &dict, T1 const &key1, T2 const &key2, T3 const &key3, T4 const &key4) |
|
template<typename F , typename Dictionary , typename T1 , typename T2 , typename T3 , typename T4 > |
arg_stream::result_type< F >::type | call_with_dictionary (F f, std::nothrow_t, Dictionary const &dict, T1 const &key1, T2 const &key2, T3 const &key3, T4 const &key4) |
|
template<typename NewFormat > |
void | callback (std::ios_base::event ev, std::ios_base &strm, int idx) |
|
template<typename T , typename Op > |
void | check_antisymmetric (const T &x, const T &y, Op op) |
|
template<typename T > |
void | check_container (const T &c) |
|
template<typename T , typename Op > |
void | check_irreflexive (const T &x, Op op) |
|
template<typename T , typename Op > |
void | check_less_than_comparable (const T &x, const T &y, const T &z, Op op) |
|
template<typename T > |
void | check_null (const T &x) |
|
template<typename T > |
void | check_regular (const T &x) |
|
template<typename T , typename Op > |
void | check_transitive (const T &x, const T &y, const T &z, Op op) |
|
template<typename T > |
void | check_traversable (const T &c) |
|
template<typename I > |
child_iterator< I > | child_begin (const I &x) |
|
template<typename I > |
child_iterator< I > | child_end (const I &x) |
|
template<typename T , typename R > |
const T & | clamp (const T &x, const T &min, const T &max, R r) |
|
template<typename T > |
const T & | clamp (const T &x, const T &min, const T &max) |
|
template<typename T , typename R > |
const T & | clamp_unordered (const T &x, const T &min, const T &max, R r) |
|
template<typename T > |
const T & | clamp_unordered (const T &x, const T &min, const T &max) |
|
template<class T , typename R > |
compare_members_t< T, R, std::less< R > > | compare_members (R T::*member) |
|
template<class T , typename R , class Compare > |
compare_members_t< T, R, Compare > | compare_members (R T::*member, Compare compare) |
|
template<typename F , typename G > |
unary_compose< F, G > | compose (F f, G g) |
|
template<typename T > |
void | construct (T *p) |
|
template<typename T > |
void | construct (T *p, T x) |
|
template<class InputRange , class OutputIterator > |
OutputIterator | copy (const InputRange &range, OutputIterator result) |
|
template<class BidirectionalRange1 , class BidirectionalIterator2 > |
BidirectionalIterator2 | copy_backward (BidirectionalRange1 &range1, BidirectionalIterator2 result) |
|
template<class BidirectionalRange1 , class BidirectionalIterator2 > |
BidirectionalIterator2 | copy_backward (const BidirectionalRange1 &range1, BidirectionalIterator2 result) |
|
template<typename I , typename F > |
std::pair< I, F > | copy_bounded (I first, I last, F result_first, F result_last) |
|
template<class InputIter , class Size , class OutputIter > |
std::pair< InputIter, OutputIter > | copy_n (InputIter first, Size count, OutputIter result) |
|
template<typename I , typename O , typename T > |
std::pair< I, O > | copy_sentinal (I f, O o, const T &x) |
|
template<typename I , typename O > |
std::pair< I, O > | copy_sentinal (I f, O o) |
|
template<class InputRange , class T > |
boost::range_difference< InputRange >::type | count (InputRange &range, T &value) |
|
template<class InputRange , class T > |
boost::range_difference< InputRange >::type | count (const InputRange &range, T &value) |
|
template<class InputIterator , class Predicate > |
std::iterator_traits< InputIterator >::difference_type | count_if (InputIterator first, InputIterator last, Predicate pred) |
|
template<class InputRange , class Predicate > |
boost::range_difference< InputRange >::type | count_if (InputRange &range, Predicate pred) |
|
template<class InputRange , class Predicate > |
boost::range_difference< InputRange >::type | count_if (const InputRange &range, Predicate pred) |
|
const char * | current_exception_what () |
|
template<typename Result , typename InputIterator > |
InputIterator | datoi (InputIterator first, InputIterator last, Result &result) |
|
template<typename T > |
void | destroy (T *p) |
|
template<typename F > |
void | destroy (F f, F l) |
|
template<typename I > |
boost::difference_type< I >::type | distance (I &range) |
|
format_base::stream_type & | end_alternate (format_base::stream_type &os) |
|
std::ostream & | end_asl_cel (std::ostream &os) |
|
std::ostream & | end_asl_cel_unsafe (std::ostream &os) |
|
format_base::stream_type & | end_atom (format_base::stream_type &os) |
|
format_base::stream_type & | end_bag (format_base::stream_type &os) |
|
format_base::stream_type & | end_format (format_base::stream_type &os) |
|
std::ostream & | end_javascript (std::ostream &os) |
|
std::ostream & | end_pdf (std::ostream &os) |
|
format_base::stream_type & | end_sequence (format_base::stream_type &os) |
|
std::ostream & | end_xml (std::ostream &os) |
|
template<typename E > |
E | eof_token () |
|
template<class InputIterator1 , class InputIterator2 , class BinaryPredicate > |
bool | equal (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, BinaryPredicate pred) |
|
template<class InputRange1 , class InputIterator2 > |
bool | equal (const InputRange1 &range1, InputIterator2 first2) |
|
template<class InputRange1 , class InputIterator2 , class BinaryPredicate > |
bool | equal (const InputRange1 &range1, InputIterator2 first2, BinaryPredicate pred) |
|
template<typename I , typename T > |
std::pair< I, I > | equal_range (I f, I l, const T &x) |
|
template<typename I , typename T , typename C > |
std::pair< I, I > | equal_range (I f, I l, const T &x, C c) |
|
template<typename I , typename T , typename C , typename P > |
std::pair< I, I > | equal_range (I f, I l, const T &x, C c, P p) |
|
template<typename I , typename T , typename C , typename P > |
boost::lazy_disable_if< boost::is_same< I, T >, implementation::lazy_range< I > >::type | equal_range (I &r, const T &x, C c, P p) |
|
template<typename I , typename T , typename C , typename P > |
boost::lazy_disable_if< boost::is_same< I, T >, implementation::lazy_range_const< I > >::type | equal_range (const I &r, const T &x, C c, P p) |
|
template<typename I , typename T > |
std::pair< typename boost::range_iterator< I >::type, typename boost::range_iterator< I >::type > | equal_range (I &r, const T &x) |
|
template<typename I , typename T > |
std::pair< typename boost::range_const_iterator< I >::type, typename boost::range_const_iterator< I >::type > | equal_range (const I &r, const T &x) |
|
template<typename I , typename T , typename C > |
boost::lazy_disable_if< boost::is_same< I, T >, implementation::lazy_range< I > >::type | equal_range (I &r, const T &x, C c) |
|
template<typename I , typename T , typename C > |
boost::lazy_disable_if< boost::is_same< I, T >, implementation::lazy_range_const< I > >::type | equal_range (const I &r, const T &x, C c) |
|
template<typename I , typename N , typename T > |
std::pair< I, I > | equal_range_n (I f, N n, const T &x) |
|
template<typename I , typename N , typename T , typename C > |
std::pair< I, I > | equal_range_n (I f, N n, const T &x, C c) |
|
template<typename I , typename N , typename T , typename C , typename P > |
std::pair< I, I > | equal_range_n (I f, N n, const T &x, C c, P p) |
|
template<typename T > |
T::iterator | erase (T &x, typename T::iterator f, typename T::iterator l) |
|
template<typename T , typename R > |
T::iterator | erase (T &x, const R &r) |
|
template<typename T > |
T::iterator | erase (T &x, typename T::iterator f) |
|
template<typename T , typename P > |
void | erase_if (T &x, typename T::iterator f, typename T::iterator l, P p) |
|
template<typename T , typename P > |
void | erase_if (T &x, P p) |
|
template<typename C > |
bool | exists (const C &c, const typename C::key_type &k) |
|
template<typename lht , typename rht > |
lht | explicit_cast (const rht &rhs) |
|
template<typename F > |
transposer< F > | f_transpose (F f) |
|
template<class ForwardRange , class T > |
void | fill (ForwardRange &range, const T &value) |
|
template<typename I , typename O , typename F > |
O | filter (I first, I last, O result, F op) |
|
template<typename I , typename O , typename F > |
O | filter (I &source, O result, F op) |
|
template<typename I , typename O , typename F > |
O | filter (const I &source, O result, F op) |
|
template<class InputRange , class T > |
boost::range_iterator< InputRange >::type | find (InputRange &range, const T &value) |
|
template<class InputRange , class T > |
boost::range_const_iterator< InputRange >::type | find (const InputRange &range, const T &value) |
|
template<typename I > |
I | find_edge (I x, std::size_t edge) |
|
template<typename I > |
I | find_edge_reverse (I x, std::size_t edge) |
|
template<class ForwardRange1 , class ForwardRange2 > |
boost::range_iterator< ForwardRange1 >::type | find_end (ForwardRange1 &range1, const ForwardRange2 &range2) |
|
template<class ForwardRange1 , class ForwardRange2 > |
boost::range_const_iterator< ForwardRange1 >::type | find_end (const ForwardRange1 &range1, const ForwardRange2 &range2) |
|
template<class ForwardIterator1 , class ForwardIterator2 , class BinaryPredicate > |
ForwardIterator1 | find_end (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate comp) |
|
template<class ForwardRange1 , class ForwardRange2 , class BinaryPredicate > |
boost::range_iterator< ForwardRange1 >::type | find_end (ForwardRange1 &range1, const ForwardRange2 &range2, BinaryPredicate comp) |
|
template<class ForwardRange1 , class ForwardRange2 , class BinaryPredicate > |
boost::range_const_iterator< ForwardRange1 >::type | find_end (const ForwardRange1 &range1, const ForwardRange2 &range2, BinaryPredicate comp) |
|
template<class InputIterator , class Predicate > |
InputIterator | find_if (InputIterator first, InputIterator last, Predicate pred) |
|
template<class InputRange , class Predicate > |
boost::range_iterator< InputRange >::type | find_if (InputRange &range, Predicate pred) |
|
template<class InputRange , class Predicate > |
boost::range_const_iterator< InputRange >::type | find_if (const InputRange &range, Predicate pred) |
|
template<class InputIterator , class Predicate > |
InputIterator | find_if_not (InputIterator first, InputIterator last, Predicate pred) |
|
template<class InputRange , class Predicate > |
boost::range_iterator< InputRange >::type | find_if_not (InputRange &range, Predicate pred) |
|
template<class InputRange , class Predicate > |
boost::range_const_iterator< InputRange >::type | find_if_not (const InputRange &range, Predicate pred) |
|
template<class InputIterator , class T , class Compare > |
InputIterator | find_match (InputIterator first, InputIterator last, const T &value, Compare comp) |
|
template<class InputRange , class T , class Compare > |
boost::range_iterator< InputRange >::type | find_match (InputRange &range, const T &value, Compare comp) |
|
template<class InputRange , class T , class Compare > |
boost::range_const_iterator< InputRange >::type | find_match (const InputRange &range, const T &value, Compare comp) |
|
template<class InputIterator , class T , class Compare > |
InputIterator | find_match (InputIterator first, InputIterator last, const T &value) |
|
template<class InputRange , class T , class Compare > |
boost::range_iterator< InputRange >::type | find_match (InputRange &range, const T &value) |
|
template<class InputRange , class T , class Compare > |
boost::range_const_iterator< InputRange >::type | find_match (const InputRange &range, const T &value) |
|
template<class InputIterator , class T > |
InputIterator | find_not (InputIterator first, InputIterator last, const T &value) |
|
template<class InputRange , class T > |
boost::range_iterator< InputRange >::type | find_not (InputRange &range, const T &value) |
|
template<class InputRange , class T > |
boost::range_const_iterator< InputRange >::type | find_not (const InputRange &range, const T &value) |
|
template<typename I > |
I | find_parent (I i) |
|
template<typename I , typename T > |
std::pair< I, I > | find_range (I f, I l, const T &x) |
|
template<typename I , typename P > |
std::pair< I, I > | find_range_if (I f, I l, P p) |
|
template<class T > |
std::ostream & | fmt (std::ostream &os, const T &t) |
|
template<class InputIterator , class UnaryFunction > |
void | for_each (InputIterator first, InputIterator last, UnaryFunction f) |
|
template<class InputRange , class UnaryFunction > |
void | for_each (InputRange &range, UnaryFunction f) |
|
template<class InputRange , class UnaryFunction > |
void | for_each (const InputRange &range, UnaryFunction f) |
|
template<class InputIterator , class UnaryFunction > |
void | for_each_position (InputIterator first, InputIterator last, UnaryFunction f) |
|
template<class InputRange , class UnaryFunction > |
void | for_each_position (InputRange &range, UnaryFunction f) |
|
template<class InputRange , class UnaryFunction > |
void | for_each_position (const InputRange &range, UnaryFunction f) |
|
template<class T > |
basic_format< T > | format (const T &t) |
|
int | format_base_idx () |
|
std::string | format_stream_error (std::istream &, const stream_error_t &) |
|
std::string | format_stream_error (const stream_error_t &) |
|
template<typename Iter , typename Pred > |
std::pair< Iter, Iter > | gather (Iter first, Iter last, Iter pivot, Pred pred) |
|
template<typename BidirectionalRange , typename Pred > |
std::pair< typename boost::range_iterator< BidirectionalRange >::type, typename boost::range_iterator< BidirectionalRange >::type > | gather (BidirectionalRange &range, typename boost::range_iterator< BidirectionalRange >::type pivot, Pred pred) |
|
template<class ForwardRange , class Generator > |
void | generate (ForwardRange &range, Generator gen) |
|
template<typename R > |
R | get_dictionary_entry (adobe::dictionary_t const &dict, adobe::name_t const &key) |
|
template<typename R > |
bool | get_dictionary_entry (adobe::dictionary_t const &dict, adobe::name_t const &key, R &r) |
|
format_base * | get_formatter (std::ostream &os) |
|
template<typename I > |
std::pair< I, std::string > | get_line (I first, I last) |
|
template<typename I > |
bool | has_children (const I &i) |
|
int | height (const place_data_t &place_data) |
|
int & | height (place_data_t &place_data) |
|
template<typename T0 > |
void | ignore_unused (const T0 &) |
|
template<typename T0 , typename T1 > |
void | ignore_unused (const T0 &, const T1 &) |
|
template<typename T0 , typename T1 , typename T2 > |
void | ignore_unused (const T0 &, const T1 &, const T2 &) |
|
template<typename T0 , typename T1 , typename T2 , typename T3 > |
void | ignore_unused (const T0 &, const T1 &, const T2 &, const T3 &) |
|
template<class InputRange1 , class InputRange2 > |
bool | includes (const InputRange1 &range1, const InputRange2 &range2) |
|
template<class InputIterator1 , class InputIterator2 , class Compare > |
bool | includes (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, Compare comp) |
|
template<class InputRange1 , class InputRange2 , class Compare > |
bool | includes (const InputRange1 &range1, const InputRange2 &range2, Compare comp) |
|
template<typename Selection , typename ForwardRange > |
Selection | index_set_to_selection (const ForwardRange &index_set) |
|
template<typename InputRange , typename InputIterator , typename T > |
T | inner_product (const InputRange &range, InputIterator first, T init) |
|
template<typename InputIterator1 , typename InputIterator2 , typename T , typename BinaryOperation1 , typename BinaryOperation2 > |
T | inner_product (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, T init, BinaryOperation1 binary_op1, BinaryOperation2 binary_op2) |
|
template<typename InputRange , typename InputIterator , typename T , typename BinaryOperation1 , typename BinaryOperation2 > |
T | inner_product (const InputRange &range, InputIterator first, T init, BinaryOperation1 binary_op1, BinaryOperation2 binary_op2) |
|
template<typename Selection > |
void | invert (Selection &x) |
|
template<class ForwardIterator , class T > |
void | iota (ForwardIterator first, ForwardIterator last, const T &value) |
|
template<class ForwardRange , class T > |
void | iota (ForwardRange &range, const T &value) |
|
template<typename I > |
bool | is_line_end (I &first, I last) |
|
template<typename I > |
std::size_t | is_line_end (I &first, I last, char c) |
|
template<typename Selection > |
bool | is_selected (const Selection &x, typename Selection::value_type index) |
|
template<typename I , typename O > |
bool | is_sorted (I f, I l, O o) |
|
template<typename I > |
bool | is_sorted (I f, I l) |
|
template<typename I , typename C , typename P > |
bool | is_sorted (I f, I l, C c, P p) |
|
template<typename I , typename C , typename P > |
bool | is_sorted (const I &r, C c, P p) |
|
template<typename I , typename C > |
bool | is_sorted (const I &r, C c) |
|
template<typename I > |
bool | is_sorted (const I &r) |
|
adobe::any_regular_t | layout_variables (adobe::sheet_t &layout_sheet, adobe::name_t name) |
|
template<typename I > |
I | leading_of (I i) |
|
int | left (const place_data_t &place_data) |
|
int & | left (place_data_t &place_data) |
|
template<class InputRange1 , class InputRange2 > |
bool | lexicographical_compare (const InputRange1 &range1, const InputRange2 &range2) |
|
template<class InputIterator1 , class InputIterator2 , class Compare > |
bool | lexicographical_compare (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, Compare comp) |
|
template<class InputRange1 , class InputRange2 , class Compare > |
bool | lexicographical_compare (const InputRange1 &range1, const InputRange2 &range2, Compare comp) |
|
std::string | localization_invoke (const std::string &source) |
|
bool | localization_ready () |
|
void | localization_register (const localization_lookup_proc_t &proc) |
|
template<typename I , typename N , typename T > |
I | lower_bound_n (I f, N n, const T &x) |
|
template<typename I , typename N , typename T , typename C > |
I | lower_bound_n (I f, N n, const T &x, C c) |
|
template<typename I , typename N , typename T , typename C , typename P > |
I | lower_bound_n (I f, N n, const T &x, C c, P p) |
|
long | lround_half_up (double x) |
|
long | lround_half_up (float x) |
|
template<typename Dictionary , typename InputRange > |
dictionary_arg_stream< Dictionary, InputRange, void > | make_dictionary_arg_stream (Dictionary &dict, InputRange const &key_range) |
|
template<typename Dictionary , typename InputRange > |
dictionary_arg_stream< Dictionary, InputRange, std::nothrow_t > | make_dictionary_arg_stream (Dictionary &dict, InputRange const &key_range, std::nothrow_t) |
|
template<class RandomAccessRange > |
void | make_heap (RandomAccessRange &range) |
|
template<class RandomAccessIterator , class Compare > |
void | make_heap (RandomAccessIterator first, RandomAccessIterator last, Compare comp) |
|
template<class RandomAccessRange , class Compare > |
void | make_heap (RandomAccessRange &range, Compare comp) |
|
template<typename I > |
is_member< I, less > | make_is_member (I f, I l) |
|
template<typename I , typename O > |
is_member< I, O > | make_is_member (I f, I l, O o) |
|
template<typename I > |
is_member< typename boost::range_const_iterator< I >::type, less > | make_is_member (const I &r) |
|
template<typename I , typename O > |
is_member< typename boost::range_const_iterator< I >::type, O > | make_is_member (const I &r, O o) |
|
template<typename T1 , typename T2 > |
pair< T1, T2 > | make_pair (T1 x, T2 y) |
|
template<typename R > |
segmented_iterator< typename boost::range_iterator< R >::type > | make_segmented_iterator (R &r) |
|
template<typename R > |
boost::iterator_range< segmented_iterator< typename boost::range_iterator< R >::type > > | make_segmented_range (R &r) |
|
std::string | make_string (const char *a, const char *b) |
|
std::string | make_string (const char *a, const char *b, const char *c) |
|
template<class T > |
const T &() | max (const T &a, const T &b) |
|
template<class T > |
T &() | max (T &a, T &b) |
|
template<class T , class Compare > |
const T &() | max (const T &a, const T &b, Compare comp) |
|
template<class T , class Compare > |
T &() | max (T &a, T &b, Compare comp) |
|
template<typename ForwardIterator > |
ForwardIterator | max_adjacent_difference (ForwardIterator first, ForwardIterator last) |
|
template<typename ForwardRange > |
boost::range_iterator< ForwardRange >::type | max_adjacent_difference (ForwardRange &range) |
|
template<typename ForwardRange > |
boost::range_const_iterator< ForwardRange >::type | max_adjacent_difference (const ForwardRange &range) |
|
template<class ForwardRange > |
boost::range_iterator< ForwardRange >::type | max_element (ForwardRange &range) |
|
template<class ForwardRange > |
boost::range_const_iterator< ForwardRange >::type | max_element (const ForwardRange &range) |
|
template<class ForwardIterator , class Compare > |
ForwardIterator | max_element (ForwardIterator first, ForwardIterator last, Compare comp) |
|
template<class ForwardRange , class Compare > |
boost::range_iterator< ForwardRange >::type | max_element (ForwardRange &range, Compare comp) |
|
template<class ForwardRange , class Compare > |
boost::range_const_iterator< ForwardRange >::type | max_element (const ForwardRange &range, Compare comp) |
|
template<class T > |
void | measure (T &t, extents_t &result) |
|
template<class T > |
void | measure_vertical (T &t, extents_t &calculated_horizontal, const place_data_t &placed_horizontal) |
|
template<typename T , typename R > |
const T & | median (const T &a, const T &b, const T &c, R r) |
|
template<typename T , typename R > |
T & | median (T &a, T &b, T &c, R r) |
|
template<typename T > |
const T & | median (const T &a, const T &b, const T &c) |
|
template<typename T > |
T & | median (T &a, T &b, T &c) |
|
template<class T , typename R > |
mem_data_t< T, R > | mem_data (R T::*member) |
|
template<class InputRange1 , class InputRange2 , class OutputIterator > |
OutputIterator | merge (const InputRange1 &range1, const InputRange2 &range2, OutputIterator result) |
|
template<class InputIterator1 , class InputIterator2 , class OutputIterator , class Compare > |
OutputIterator | merge (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp) |
|
template<class InputRange1 , class InputRange2 , class OutputIterator , class Compare > |
OutputIterator | merge (const InputRange1 &range1, const InputRange2 &range2, OutputIterator result, Compare comp) |
|
template<class T > |
const T &() | min (const T &a, const T &b) |
|
template<class T > |
T &() | min (T &a, T &b) |
|
template<class T , class Compare > |
const T &() | min (const T &a, const T &b, Compare comp) |
|
template<class T , class Compare > |
T &() | min (T &a, T &b, Compare comp) |
|
template<class ForwardRange > |
boost::range_iterator< ForwardRange >::type | min_element (ForwardRange &range) |
|
template<class ForwardRange > |
boost::range_const_iterator< ForwardRange >::type | min_element (const ForwardRange &range) |
|
template<class ForwardIterator , class Compare > |
ForwardIterator | min_element (ForwardIterator first, ForwardIterator last, Compare comp) |
|
template<class ForwardRange , class Compare > |
boost::range_iterator< ForwardRange >::type | min_element (ForwardRange &range, Compare comp) |
|
template<class ForwardRange , class Compare > |
boost::range_const_iterator< ForwardRange >::type | min_element (const ForwardRange &range, Compare comp) |
|
template<class InputRange1 , class InputIterator2 > |
std::pair< typename boost::range_iterator< InputRange1 >::type, InputIterator2 > | mismatch (InputRange1 &range1, InputIterator2 first2) |
|
template<class InputRange1 , class InputIterator2 > |
std::pair< typename boost::range_const_iterator< InputRange1 >::type, InputIterator2 > | mismatch (const InputRange1 &range1, InputIterator2 first2) |
|
template<typename I1 , typename I2 > |
std::pair< I1, I2 > | mismatch (I1 first1, I1 last1, I2 first2, I2 last2) |
|
template<class InputIterator1 , class InputIterator2 , class BinaryPredicate > |
std::pair< InputIterator1, InputIterator2 > | mismatch (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, BinaryPredicate pred) |
|
template<class InputRange1 , class InputIterator2 , class BinaryPredicate > |
std::pair< typename boost::range_iterator< InputRange1 >::type, InputIterator2 > | mismatch (InputRange1 &range1, InputIterator2 first2, BinaryPredicate pred) |
|
template<class InputRange1 , class InputIterator2 , class BinaryPredicate > |
std::pair< typename boost::range_const_iterator< InputRange1 >::type, InputIterator2 > | mismatch (const InputRange1 &range1, InputIterator2 first2, BinaryPredicate pred) |
|
template<typename I1 , typename I2 , typename N > |
std::pair< I1, I2 > | mismatch_n (I1 first1, I2 first2, N n) |
|
template<typename T > |
T | move (T &x, typename move_sink< T >::type=0) |
|
template<typename T > |
T & | move (T &x, typename copy_sink< T >::type=0) |
|
template<typename I , typename O > |
O | move (I f, I l, O result) |
|
template<typename I , typename O > |
O | move (I &in, O out) |
|
template<typename I , typename O > |
O | move_backward (I f, I l, O result) |
|
template<typename I , typename O > |
O | move_backward (I &in, O out) |
|
template<typename R , typename A > |
R | nearest_cast (const A &x) |
|
template<class BidirectionalRange > |
bool | next_permutation (BidirectionalRange &range) |
|
template<class BidirectionalIterator , class Compare > |
bool | next_permutation (BidirectionalIterator first, BidirectionalIterator last, Compare comp) |
|
template<class BidirectionalRange , class Compare > |
bool | next_permutation (BidirectionalRange &range, Compare comp) |
|
template<typename D , typename IT , typename S_FN > |
bool | operator!= (const step_iterator_adaptor< D, IT, S_FN > &p1, const step_iterator_adaptor< D, IT, S_FN > &p2) |
|
template<class T > |
bool | operator!= (const poly< T > &x, const poly< T > &y) |
|
template<typename T > |
bool | operator!= (const forest< T > &x, const forest< T > &y) |
|
template<typename D , typename IT , typename S_FN > |
bool | operator< (const step_iterator_adaptor< D, IT, S_FN > &p1, const step_iterator_adaptor< D, IT, S_FN > &p2) |
|
template<class ArgumentType1 , class ArgumentType2 , class charT , class traits > |
std::basic_ostream< charT, traits > & | operator<< (std::basic_ostream< charT, traits > &os, const adobe::basic_omanipulator2< ArgumentType1, ArgumentType2, charT, traits > &manip) |
|
template<class ArgumentType , class charT , class traits > |
std::basic_ostream< charT, traits > & | operator<< (std::basic_ostream< charT, traits > &os, const adobe::basic_omanipulator< ArgumentType, charT, traits > &manip) |
|
std::ostream & | operator<< (std::ostream &s, const extents_t &x) |
|
std::ostream & | operator<< (std::ostream &s, const extents_t::slice_t &x) |
|
std::ostream & | operator<< (std::ostream &, const line_position_t &) |
|
template<typename T , class charT , class traits > |
std::basic_ostream< charT, traits > & | operator<< (std::basic_ostream< charT, traits > &os, const begin_atom< T > &manip) |
|
std::ostream & | operator<< (std::ostream &s, const token_range_t &x) |
|
template<typename D , typename IT , typename S_FN > |
bool | operator<= (const step_iterator_adaptor< D, IT, S_FN > &p1, const step_iterator_adaptor< D, IT, S_FN > &p2) |
|
template<typename T > |
bool | operator== (const circular_queue< T > &x, const circular_queue< T > &y) |
|
template<typename D , typename IT , typename S_FN > |
bool | operator== (const step_iterator_adaptor< D, IT, S_FN > &p1, const step_iterator_adaptor< D, IT, S_FN > &p2) |
|
template<class J , template< typename > class K> |
boost::enable_if< implementation::has_equals< J >, bool >::type | operator== (const poly_base< J, K > &x, const poly_base< J, K > &y) |
|
template<typename T > |
bool | operator== (const forest< T > &x, const forest< T > &y) |
|
template<typename D , typename IT , typename S_FN > |
bool | operator> (const step_iterator_adaptor< D, IT, S_FN > &p1, const step_iterator_adaptor< D, IT, S_FN > &p2) |
|
template<typename D , typename IT , typename S_FN > |
bool | operator>= (const step_iterator_adaptor< D, IT, S_FN > &p1, const step_iterator_adaptor< D, IT, S_FN > &p2) |
|
template<typename T , typename P , typename BinaryPredicate > |
const T & | other_of (const P &pair, const T &x, BinaryPredicate pred) |
|
template<typename T , typename P > |
const T & | other_of (const P &pair, const T &x) |
|
void | parse (std::istream &stream, const line_position_t &position, const adam_callback_suite_t &callbacks) |
|
line_position_t | parse (std::istream &in, const line_position_t &, const eve_callback_suite_t::position_t &, const eve_callback_suite_t &) |
|
array_t | parse_adam_expression (const std::string &expression) |
|
template<typename O > |
void | parse_xml_fragment (uchar_ptr_t fragment, std::size_t n, O output) |
|
template<typename O > |
void | parse_xml_fragment (const std::string &fragment, O output) |
|
template<typename O > |
void | parse_xml_fragment (const char *fragment, O output) |
|
template<class InputRange , class RandomAccessRange > |
void | partial_sort_copy (InputRange &range, RandomAccessRange &result_range) |
|
template<class InputRange , class RandomAccessRange > |
void | partial_sort_copy (const InputRange &range, RandomAccessRange &result_range) |
|
template<class InputIterator , class RandomAccessIterator , class Compare > |
void | partial_sort_copy (InputIterator first, InputIterator last, RandomAccessIterator result_first, RandomAccessIterator result_last, Compare comp) |
|
template<class InputRange , class RandomAccessRange , class Compare > |
void | partial_sort_copy (InputRange &range, RandomAccessRange &result_range, Compare comp) |
|
template<class InputRange , class RandomAccessRange , class Compare > |
void | partial_sort_copy (const InputRange &range, RandomAccessRange &result_range, Compare comp) |
|
template<typename InputRange , typename OutputIterator > |
OutputIterator | partial_sum (const InputRange &range, OutputIterator result) |
|
template<typename InputIterator , typename OutputIterator , typename BinaryOperation > |
OutputIterator | partial_sum (InputIterator first, InputIterator last, OutputIterator result, BinaryOperation binary_op) |
|
template<typename InputRange , typename OutputIterator , typename BinaryOperation > |
OutputIterator | partial_sum (const InputRange &range, OutputIterator result, BinaryOperation binary_op) |
|
template<class BidirectionalIterator , class Predicate > |
BidirectionalIterator | partition (BidirectionalIterator first, BidirectionalIterator last, Predicate pred) |
|
template<class BidirectionalRange , class Predicate > |
boost::range_iterator< BidirectionalRange >::type | partition (BidirectionalRange &range, Predicate pred) |
|
template<typename T , typename R > |
const T & | pin (const T &min, const T &x, const T &max, R r) |
|
template<typename T > |
const T & | pin (const T &min, const T &x, const T &max) |
|
template<typename T , typename R > |
const T & | pin_safe (const T &min, const T &x, const T &max, R r) |
|
template<typename T , typename R > |
const T & | pin_safe (const T &min, const T &x, const T &max) |
|
template<typename I > |
void | pivot (I &i) |
|
template<typename I > |
I | pivot_of (I i) |
|
template<class T > |
void | place (T &t, const place_data_t &place_data) |
|
template<typename T , typename U > |
T | poly_cast (poly< U > &x) |
|
template<typename T , typename U > |
T | poly_cast (const poly< U > &x) |
|
template<typename T , typename U > |
T | poly_cast (poly< U > *x) |
|
template<typename T , typename U > |
T | poly_cast (const poly< U > *x) |
|
template<class RandomAccessRange > |
void | pop_heap (RandomAccessRange &range) |
|
template<class RandomAccessIterator , class Compare > |
void | pop_heap (RandomAccessIterator first, RandomAccessIterator last, Compare comp) |
|
template<class RandomAccessRange , class Compare > |
void | pop_heap (RandomAccessRange &range, Compare comp) |
|
template<class BidirectionalRange > |
bool | prev_permutation (BidirectionalRange &range) |
|
template<class BidirectionalIterator , class Compare > |
bool | prev_permutation (BidirectionalIterator first, BidirectionalIterator last, Compare comp) |
|
template<class BidirectionalRange , class Compare > |
bool | prev_permutation (BidirectionalRange &range, Compare comp) |
|
template<class RandomAccessRange > |
void | push_heap (RandomAccessRange &range) |
|
template<class RandomAccessIterator , class Compare > |
void | push_heap (RandomAccessIterator first, RandomAccessIterator last, Compare comp) |
|
template<class RandomAccessRange , class Compare > |
void | push_heap (RandomAccessRange &range, Compare comp) |
|
template<class RandomAccessRange > |
void | random_shuffle (RandomAccessRange &range) |
|
template<class RandomAccessIterator , class RandomNumberGenerator > |
void | random_shuffle (RandomAccessIterator first, RandomAccessIterator last, RandomNumberGenerator &rand) |
|
template<class RandomAccessRange , class RandomNumberGenerator > |
void | random_shuffle (RandomAccessRange &range, RandomNumberGenerator &rand) |
|
template<typename I , typename Op > |
std::iterator_traits< I >::value_type | reduce_balanced (I f, I l, Op op, ADOBE_VALUE_TYPE(I) z=adobe::identity_element< Op >()()) |
|
template<typename I , typename Op > |
std::iterator_traits< I >::value_type | reduce_nonzeros (I f, I l, Op op, ADOBE_VALUE_TYPE(I) z=adobe::identity_element< Op >()()) |
|
template<class InputRange , class T > |
boost::range_iterator< InputRange >::type | remove (InputRange &range, const T &value) |
|
template<typename T > |
T & | remove_const (const T &x) |
|
template<class InputRange , class OutputIterator , class T > |
boost::range_iterator< InputRange >::type | remove_copy (InputRange &range, OutputIterator result, const T &value) |
|
template<class InputRange , class OutputIterator , class T > |
boost::range_const_iterator< InputRange >::type | remove_copy (const InputRange &range, OutputIterator result, const T &value) |
|
template<class InputIterator , class OutputIterator , class Predicate > |
InputIterator | remove_copy_if (InputIterator first, InputIterator last, OutputIterator result, Predicate pred) |
|
template<class InputRange , class OutputIterator , class Predicate > |
boost::range_iterator< InputRange >::type | remove_copy_if (InputRange &range, OutputIterator result, Predicate pred) |
|
template<class InputRange , class OutputIterator , class Predicate > |
boost::range_const_iterator< InputRange >::type | remove_copy_if (const InputRange &range, OutputIterator result, Predicate pred) |
|
template<class InputIterator , class Predicate > |
InputIterator | remove_if (InputIterator first, InputIterator last, Predicate pred) |
|
template<class InputRange , class Predicate > |
boost::range_iterator< InputRange >::type | remove_if (InputRange &range, Predicate pred) |
|
template<class ForwardRange , class T > |
void | replace (ForwardRange &range, const T &old_value, const T &new_value) |
|
template<class ForwardRange , class OutputIterator , class T > |
OutputIterator | replace_copy (ForwardRange &range, OutputIterator result, const T &old_value, const T &new_value) |
|
template<class ForwardRange , class OutputIterator , class T > |
OutputIterator | replace_copy (const ForwardRange &range, OutputIterator result, const T &old_value, const T &new_value) |
|
template<class ForwardIterator , class OutputIterator , class Predicate , class T > |
OutputIterator | replace_copy_if (ForwardIterator first, ForwardIterator last, OutputIterator result, Predicate pred, const T &new_value) |
|
template<class ForwardRange , class OutputIterator , class Predicate , class T > |
OutputIterator | replace_copy_if (ForwardRange &range, OutputIterator result, Predicate pred, const T &new_value) |
|
template<class ForwardRange , class OutputIterator , class Predicate , class T > |
OutputIterator | replace_copy_if (const ForwardRange &range, OutputIterator result, Predicate pred, const T &new_value) |
|
template<class ForwardIterator , class Predicate , class T > |
void | replace_if (ForwardIterator first, ForwardIterator last, Predicate pred, const T &new_value) |
|
template<class ForwardRange , class Predicate , class T > |
void | replace_if (ForwardRange &range, Predicate pred, const T &new_value) |
|
template<typename OldFormat , typename NewFormat > |
void | replace_pword (std::ios_base &iob, int idx) |
|
template<typename OldFormat , typename NewFormat , typename T > |
void | replace_pword (std::ios_base &iob, int idx, const T &x) |
|
template<class BidirectionalRange > |
void | reverse (BidirectionalRange &range) |
|
template<class BidirectionalRange , class OutputIterator > |
void | reverse_copy (BidirectionalRange &range, OutputIterator result) |
|
template<class BidirectionalRange , class OutputIterator > |
void | reverse_copy (const BidirectionalRange &range, OutputIterator result) |
|
template<typename I > |
std::pair< I, I > | reverse_until (I f, I m, I l) |
|
int | right (const place_data_t &place_data) |
|
template<typename I > |
std::pair< I, I > | rotate (I f, I m, I l, std::bidirectional_iterator_tag) |
|
template<typename I > |
std::pair< I, I > | rotate (I f, I m, I l) |
|
double | round_half_up (double x) |
|
float | round_half_up (float x) |
|
template<typename R , typename T > |
R | runtime_cast (T &x) |
|
template<typename R , typename T > |
R | runtime_cast (T *x) |
|
template<typename R , typename T > |
bool | runtime_cast (const T &x, R &r) |
|
template<class ForwardRange1 , class ForwardRange2 > |
boost::range_const_iterator< ForwardRange1 >::type | search (const ForwardRange1 &range1, const ForwardRange2 &range2) |
|
template<class ForwardRange1 , class ForwardRange2 > |
boost::range_iterator< ForwardRange1 >::type | search (ForwardRange1 &range1, const ForwardRange2 &range2) |
|
template<class ForwardIterator1 , class ForwardIterator2 , class BinaryPredicate > |
ForwardIterator1 | search (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred) |
|
template<class ForwardRange1 , class ForwardRange2 , class BinaryPredicate > |
boost::range_iterator< ForwardRange1 >::type | search (ForwardRange1 &range1, const ForwardRange2 &range2, BinaryPredicate pred) |
|
template<class ForwardRange1 , class ForwardRange2 , class BinaryPredicate > |
boost::range_const_iterator< ForwardRange1 >::type | search (const ForwardRange1 &range1, const ForwardRange2 &range2, BinaryPredicate pred) |
|
template<class ForwardRange , class Size , class T > |
boost::range_iterator< ForwardRange >::type | search_n (ForwardRange &range, Size count, const T &value) |
|
template<class ForwardRange , class Size , class T > |
boost::range_const_iterator< ForwardRange >::type | search_n (const ForwardRange &range, Size count, const T &value) |
|
template<class ForwardIterator , class Size , class T , class BinaryPredicate > |
ForwardIterator | search_n (ForwardIterator first, ForwardIterator last, Size count, const T &value, BinaryPredicate pred) |
|
template<class ForwardRange , class Size , class T , class BinaryPredicate > |
boost::range_iterator< ForwardRange >::type | search_n (ForwardRange &range, Size count, const T &value, BinaryPredicate pred) |
|
template<class ForwardRange , class Size , class T , class BinaryPredicate > |
boost::range_const_iterator< ForwardRange >::type | search_n (const ForwardRange &range, Size count, const T &value, BinaryPredicate pred) |
|
template<typename T , typename R > |
const T & | select_1 (const T &a, const T &b, const T &c, R r) |
|
template<typename T , typename R > |
T & | select_1 (T &a, T &b, T &c, R r) |
|
template<typename T , typename R > |
const T & | select_1_ab (const T &a, const T &b, const T &c, R r) |
|
template<typename T , typename R > |
T & | select_1_ab (T &a, T &b, T &c, R r) |
|
template<typename T , typename R > |
const T & | select_1_ac (const T &a, const T &b, const T &c, R r) |
|
template<typename T , typename R > |
T & | select_1_ac (T &a, T &b, T &c, R r) |
|
template<typename Selection , typename ForwardRange , typename OutputIterator > |
OutputIterator | selection_copy (const Selection &x, const ForwardRange &range, OutputIterator output) |
|
template<typename S1 , typename S2 , typename O , typename C > |
O | selection_difference (S1 s1_first, S1 s1_last, S2 s2_first, S2 s2_last, O output, C comp, bool s1_inside=false, bool s2_inside=false) |
|
template<typename Selection1 , typename Selection2 > |
Selection1 | selection_difference (const Selection1 &x, const Selection2 &y) |
|
template<typename Selection > |
std::pair< typename boost::range_const_iterator< Selection >::type, typename boost::range_size< Selection >::type > | selection_find_boundary (const Selection &selection, typename Selection::size_type p, std::random_access_iterator_tag) |
|
template<typename Selection > |
std::pair< typename boost::range_const_iterator< Selection >::type, typename boost::range_size< Selection >::type > | selection_find_boundary (const Selection &selection, typename Selection::size_type p, std::forward_iterator_tag) |
|
template<typename Selection > |
std::pair< typename boost::range_const_iterator< Selection >::type, typename boost::range_size< Selection >::type > | selection_find_boundary (const Selection &selection, typename Selection::size_type p) |
|
template<typename Selection , typename ForwardRange , typename UnaryFunction > |
UnaryFunction | selection_foreach (const Selection &x, const ForwardRange &range, UnaryFunction proc) |
|
template<typename S1 , typename S2 , typename C > |
bool | selection_includes (S1 s1_first, S1 s1_last, S2 s2_first, S2 s2_last, C comp, bool s1_inside=false, bool s2_inside=false) |
|
template<typename Selection1 , typename Selection2 > |
bool | selection_includes (const Selection1 &x, const Selection2 &y) |
|
template<typename S1 , typename S2 , typename O , typename C > |
O | selection_intersection (S1 s1_first, S1 s1_last, S2 s2_first, S2 s2_last, O output, C comp, bool s1_inside=false, bool s2_inside=false) |
|
template<typename Selection1 , typename Selection2 > |
Selection1 | selection_intersection (const Selection1 &x, const Selection2 &y) |
|
template<typename S1 , typename S2 , typename O , typename P , typename C > |
O | selection_operation (S1 s1_first, S1 s1_last, S2 s2_first, S2 s2_last, O output, bool s1_inside, bool s2_inside, P pred, C comp) |
|
template<typename S , typename O , typename P > |
O | selection_operation_remainder (S first, S last, O output, bool this_inside, bool other_inside, P pred) |
|
template<typename Selection , typename ForwardRange , typename O1 , typename O2 > |
std::pair< O1, O2 > | selection_partition_copy (const Selection &selection, ForwardRange &range, O1 false_output, O2 true_output) |
|
template<typename SelectionIterator , typename RangeIterator > |
RangeIterator | selection_stable_partition (SelectionIterator selection_first, SelectionIterator selection_last, RangeIterator first, RangeIterator range_first, RangeIterator range_last, std::size_t boundary_count=0) |
|
template<typename Selection , typename ForwardRange > |
boost::range_iterator< ForwardRange >::type | selection_stable_partition (const Selection &selection, ForwardRange &range) |
|
template<typename Selection , typename ForwardRange > |
std::pair< typename boost::range_iterator< ForwardRange >::type, typename boost::range_iterator< ForwardRange >::type > | selection_stable_partition_about (const Selection &selection, ForwardRange &range, std::size_t p, typename boost::range_size< Selection >::type prior_boundary_count=0) |
|
template<typename S1 , typename S2 , typename O , typename C > |
O | selection_symmetric_difference (S1 s1_first, S1 s1_last, S2 s2_first, S2 s2_last, O output, C comp, bool s1_inside=false, bool s2_inside=false) |
|
template<typename Selection1 , typename Selection2 > |
Selection1 | selection_symmetric_difference (const Selection1 &x, const Selection2 &y) |
|
template<typename Selection , typename OutputIterator > |
OutputIterator | selection_to_index_set (const Selection &selection, typename boost::range_size< Selection >::type max_index, OutputIterator output) |
|
template<typename S1 , typename S2 , typename O , typename C > |
O | selection_union (S1 s1_first, S1 s1_last, S2 s2_first, S2 s2_last, O output, C comp, bool s1_inside=false, bool s2_inside=false) |
|
template<typename Selection1 , typename Selection2 > |
Selection1 | selection_union (const Selection1 &x, const Selection2 &y) |
|
template<class InputRange1 , class InputRange2 , class OutputIterator > |
OutputIterator | set_difference (const InputRange1 &range1, const InputRange2 &range2, OutputIterator result) |
|
template<class InputIterator1 , class InputIterator2 , class OutputIterator , class Compare > |
OutputIterator | set_difference (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp) |
|
template<class InputRange1 , class InputRange2 , class OutputIterator , class Compare > |
OutputIterator | set_difference (const InputRange1 &range1, const InputRange2 &range2, OutputIterator result, Compare comp) |
|
template<class InputRange1 , class InputRange2 , class OutputIterator > |
OutputIterator | set_intersection (const InputRange1 &range1, const InputRange2 &range2, OutputIterator result) |
|
template<class InputIterator1 , class InputIterator2 , class OutputIterator , class Compare > |
OutputIterator | set_intersection (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp) |
|
template<class InputRange1 , class InputRange2 , class OutputIterator , class Compare > |
OutputIterator | set_intersection (const InputRange1 &range1, const InputRange2 &range2, OutputIterator result, Compare comp) |
|
void | set_margin (layout_attributes_t &container, int x) |
|
template<class InputRange1 , class InputRange2 , class OutputIterator > |
OutputIterator | set_symmetric_difference (const InputRange1 &range1, const InputRange2 &range2, OutputIterator result) |
|
template<class InputIterator1 , class InputIterator2 , class OutputIterator , class Compare > |
OutputIterator | set_symmetric_difference (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp) |
|
template<class InputRange1 , class InputRange2 , class OutputIterator , class Compare > |
OutputIterator | set_symmetric_difference (const InputRange1 &range1, const InputRange2 &range2, OutputIterator result, Compare comp) |
|
template<class InputRange1 , class InputRange2 , class OutputIterator > |
OutputIterator | set_union (const InputRange1 &range1, const InputRange2 &range2, OutputIterator result) |
|
template<class InputIterator1 , class InputIterator2 , class OutputIterator , class Compare > |
OutputIterator | set_union (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp) |
|
template<class InputRange1 , class InputRange2 , class OutputIterator , class Compare > |
OutputIterator | set_union (const InputRange1 &range1, const InputRange2 &range2, OutputIterator result, Compare comp) |
|
template<typename Selection > |
boost::range_size< Selection >::type | size (const Selection &x) |
|
template<typename Selection , typename ForwardRange > |
boost::range_size< Selection >::type | size (const Selection &x, const ForwardRange &range) |
|
template<class RandomAccessRange > |
void | sort (RandomAccessRange &range) |
|
template<class RandomAccessIterator , class Compare > |
void | sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp) |
|
template<typename I , typename C , typename P > |
void | sort (I f, I l, C c, P p) |
|
template<typename R , typename C , typename P > |
void | sort (R &r, C c, P p) |
|
template<class RandomAccessRange , class Compare > |
void | sort (RandomAccessRange &range, Compare comp) |
|
template<class RandomAccessRange > |
void | sort_heap (RandomAccessRange &range) |
|
template<class RandomAccessIterator , class Compare > |
void | sort_heap (RandomAccessIterator first, RandomAccessIterator last, Compare comp) |
|
template<class RandomAccessRange , class Compare > |
void | sort_heap (RandomAccessRange &range, Compare comp) |
|
template<typename I , typename O > |
I | sorted (I f, I l, O o) |
|
template<typename I > |
I | sorted (I f, I l) |
|
template<class BidirectionalIterator , class Predicate > |
BidirectionalIterator | stable_partition (BidirectionalIterator first, BidirectionalIterator last, Predicate pred) |
|
template<class BidirectionalRange , class Predicate > |
boost::range_iterator< BidirectionalRange >::type | stable_partition (BidirectionalRange &range, Predicate pred) |
|
template<class RandomAccessRange > |
void | stable_sort (RandomAccessRange &range) |
|
template<class RandomAccessIterator , class Compare > |
void | stable_sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp) |
|
template<class RandomAccessRange , class Compare > |
void | stable_sort (RandomAccessRange &range, Compare comp) |
|
template<typename Selection > |
bool | start_selected (const Selection &x) |
|
template<typename T > |
token_range_t | static_token_range (T *begin) |
|
int | strcmp (const char *x, const char *y) |
|
template<typename T > |
void | swap (circular_queue< T > &, circular_queue< T > &) |
|
template<typename T > |
void | swap (forest< T > &, forest< T > &) |
|
template<class ForwardRange1 , class ForwardIterator2 > |
ForwardIterator2 | swap_ranges (ForwardRange1 &range1, ForwardIterator2 first2) |
|
thread_id_t | thread_id () |
|
template<typename I , typename O > |
boost::enable_if< is_utf8_iterator_type< I >, O >::type | to_utf16 (I first, I last, O output) |
|
template<typename I , typename O > |
boost::enable_if< is_utf16_iterator_type< I >, O >::type | to_utf16 (I first, I last, O output) |
|
template<typename I > |
boost::enable_if< is_utf8_iterator_type< I >, boost::uint16_t >::type | to_utf16 (I first, I last) |
|
template<typename I , typename O > |
O | to_utf32 (I first, I last, O output) |
|
template<typename I > |
boost::uint32_t | to_utf32 (I first, I last) |
|
template<typename I , typename O > |
boost::enable_if< is_utf16_iterator_type< I >, O >::type | to_utf8 (I first, I last, O output) |
|
template<typename I , typename O > |
boost::enable_if< is_utf32_iterator_type< I >, O >::type | to_utf8 (I first, I last, O output) |
|
template<typename I , typename O > |
boost::enable_if< is_utf8_iterator_type< I >, O >::type | to_utf8 (I first, I last, O output) |
|
bool | token_range_equal (const token_range_t &x, const token_range_t &y) |
|
bool | token_range_less (const token_range_t &x, const token_range_t &y) |
|
int | top (const place_data_t &place_data) |
|
int & | top (place_data_t &place_data) |
|
template<typename I > |
I | trailing_of (I i) |
|
template<class InputIterator , class OutputIterator , class UnaryOperation > |
OutputIterator | transform (InputIterator first, InputIterator last, OutputIterator result, UnaryOperation op) |
|
template<class InputRange , class OutputIterator , class UnaryOperation > |
OutputIterator | transform (InputRange &range, OutputIterator result, UnaryOperation op) |
|
template<class InputRange , class OutputIterator , class UnaryOperation > |
OutputIterator | transform (const InputRange &range, OutputIterator result, UnaryOperation op) |
|
template<class InputIterator1 , class InputIterator2 , class OutputIterator , class BinaryOperation > |
OutputIterator | transform (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, BinaryOperation binary_op) |
|
template<class InputRange1 , class InputIterator2 , class OutputIterator , class BinaryOperation > |
OutputIterator | transform (InputRange1 &range1, InputIterator2 first2, OutputIterator result, BinaryOperation binary_op) |
|
template<class InputRange1 , class InputIterator2 , class OutputIterator , class BinaryOperation > |
OutputIterator | transform (const InputRange1 &range1, InputIterator2 first2, OutputIterator result, BinaryOperation binary_op) |
|
template<typename I , typename F > |
F | uninitialized_move (I f, I l, F r) |
|
template<class ForwardRange > |
boost::range_iterator< ForwardRange >::type | unique (ForwardRange &range) |
|
template<class ForwardIterator , class BinaryPredicate > |
ForwardIterator | unique (ForwardIterator first, ForwardIterator last, BinaryPredicate pred) |
|
template<class ForwardRange , class BinaryPredicate > |
boost::range_iterator< ForwardRange >::type | unique (ForwardRange &range, BinaryPredicate pred) |
|
template<class InputRange , class OutputIterator > |
OutputIterator | unique_copy (InputRange &range, OutputIterator result) |
|
template<class InputRange , class OutputIterator > |
OutputIterator | unique_copy (const InputRange &range, OutputIterator result) |
|
template<class InputIterator , class OutputIterator , class BinaryPredicate > |
OutputIterator | unique_copy (InputIterator first, InputIterator last, OutputIterator result, BinaryPredicate pred) |
|
template<class InputRange , class OutputIterator , class BinaryPredicate > |
OutputIterator | unique_copy (InputRange &range, OutputIterator result, BinaryPredicate pred) |
|
template<class InputRange , class OutputIterator , class BinaryPredicate > |
OutputIterator | unique_copy (const InputRange &range, OutputIterator result, BinaryPredicate pred) |
|
template<typename I , typename N , typename T > |
I | upper_bound_n (I f, N n, const T &x) |
|
template<typename I , typename N , typename T , typename C > |
I | upper_bound_n (I f, N n, const T &x, C c) |
|
template<typename I , typename N , typename T , typename C , typename P > |
I | upper_bound_n (I f, N n, const T &x, C c, P p) |
|
template<typename T , typename O > |
boost::enable_if< is_utf32_type< T >, O >::type | value_to_utf16 (T code, O output) |
|
template<typename T , typename O > |
boost::enable_if< is_utf32_type< T >, O >::type | value_to_utf8 (T code, O output) |
|
template<typename T , typename O > |
boost::enable_if< is_utf16_type< T >, O >::type | value_to_utf8 (T code, O output) |
|
template<typename T , typename O > |
boost::enable_if< is_utf8_type< T >, O >::type | value_to_utf8 (T code, O output) |
|
int | width (const place_data_t &place_data) |
|
int & | width (place_data_t &place_data) |
|
template<typename Result , typename InputIterator > |
InputIterator | xatoi (InputIterator first, InputIterator last, Result &result) |
|
token_range_t | xml_element_echo (const token_range_t &entire_element_range, const token_range_t &, const attribute_set_t &, const token_range_t &) |
|
token_range_t | xml_element_linefeed (const token_range_t &, const token_range_t &name, const attribute_set_t &attribute_set, const token_range_t &value) |
|
token_range_t | xml_element_strip (const token_range_t &, const token_range_t &, const attribute_set_t &, const token_range_t &value) |
|
template<typename O > |
void | xstring (const char *xstr, std::size_t n, O output) |
|
template<typename O > |
void | xstring (const char *xstr, O output) |
|
std::string | xstring (const char *xstr, std::size_t n) |
|
std::string | xstring (const std::string &xstr) |
|
void | xstring_clear_glossary () |
|
std::string | xstring_replace (const std::string &xstr, const std::string &marker) |
|
std::string | xstring_replace (const std::string &xstr, const std::string *first, const std::string *last) |
|
std::string | xstring_replace (const name_t &xstr_id, const std::string &marker) |
|
std::string | xstring_replace (const name_t &xstr_id, const std::string *first, const std::string *last) |
|