Namespaces |
namespace | arg_stream |
namespace | detail |
namespace | dictionary_arg_stream_detail |
namespace | fn |
namespace | unsafe |
namespace | version_0 |
namespace | version_1 |
Classes |
class | adam_callback_suite_t |
| Callback class for the Adam parser. More...
|
struct | aggregate_pair |
struct | aligned_storage |
struct | always_true |
struct | any_bidirectional_iterator_instance |
struct | any_bidirectional_iterator_interface |
class | any_iterator |
| An iterator wrapping another iterator of the same element type; a "polymorphic" iterator. More...
|
struct | any_random_access_iterator_instance |
struct | any_random_access_iterator_interface |
class | asl_cel_format |
struct | assign |
class | attribute_set_t |
| An associated array based on adobe::token_range_t. A utility class for the xml_parser_t. More...
|
class | auto_ptr |
| The adobe::auto_ptr<> template adds a number of extensions to std::auto_ptr<> . More...
|
class | auto_resource |
| The template class auto_resource< X, Traits > provides similar functionality to auto_ptr for resources for which the pointer is opaque refered to by a non-pointer type. More...
|
class | back_move_iterator |
| Similar to std::back_insert_iterator but with move semantics, for movable types, otherwise with copy semantics. More...
|
class | bad_cast |
| An exception class thrown during ASL failures to cast. More...
|
class | basic_bounded_width |
class | basic_format |
class | basic_omanipulator |
class | basic_omanipulator2 |
class | begin_atom |
class | begin_bag |
struct | bidirectional_iter |
struct | binary_compose |
class | bitwise_and |
| operator() returns x & y . More...
|
class | bitwise_or |
| operator() returns x | y . More...
|
class | bitwise_xor |
| operator() returns x ^ y . More...
|
class | child_adaptor |
class | child_iterator |
| An iterator used to traverse the children of a specific node in a forest. More...
|
class | circular_queue |
| A queue with a fixed capacity which supports putting back elements. Pushing more elements than there is capacity will pop the least recently pushed elements. More...
|
class | closed_hash_map |
| A hash based associative container. More...
|
class | closed_hash_set |
| A hash based associative container. More...
|
class | compare_members_t |
| Utility class for adobe::compare_members. More...
|
class | const_once_name_t |
| Utility wrapper to construct name_t without initializing the string pointer. More...
|
struct | constructor |
struct | copy_sink |
| copy_sink and move_sink are used to select between overloaded operations according to whether type T is movable and convertible to type U. More...
|
struct | copyable |
| "Handle" class used in poly<copyable> implementation. More...
|
class | counter_t |
| A thread safe counter. More...
|
class | counting_output_iterator |
class | dancing_links |
| An optimized implementation of the 1-cover problem [class under review]. More...
|
class | dancing_links_t |
struct | dec |
| operator-- wrapped in a function object More...
|
struct | delete_array |
| A function object for type T that invokes delete [] on an array of T . More...
|
struct | delete_ptr |
| A function object for type T that invokes delete on a T* . More...
|
struct | delete_ptr_trait< T * > |
struct | delete_ptr_trait< T(*)[]> |
class | depth_fullorder_cursor |
| An iterator-like type for the depth-tracked traversal of a forest. More...
|
class | depth_fullorder_iterator |
struct | dictionary_arg_stream |
| dictionary_arg_stream implements the arg_stream interface More...
|
struct | dictionary_arg_stream< Dictionary, InputRange, std::nothrow_t > |
struct | dictionary_arg_stream_base |
class | edge_iterator |
| An iterator used to traverse a specific edge type within a forest. More...
|
struct | element |
struct | element< 0, pair< T1, T2 > > |
struct | element< 0, std::pair< T1, T2 > > |
struct | element< 1, pair< T1, T2 > > |
struct | element< 1, std::pair< T1, T2 > > |
struct | empty_base |
struct | empty_ptr< T * > |
struct | empty_ptr< T(*)[]> |
struct | equal_to |
struct | equivalent |
struct | eve_callback_suite_t |
class | eve_t |
| Eve engine. More...
|
class | extents_slices_t |
| A utility class for referencing the two slices of a extents_t. More...
|
class | extents_t |
| An intrinsic geometry class for objects with a graphical representation. More...
|
class | external_model_t |
class | filter_fullorder_cursor |
| An iterator-like type for fullorder (pre- and post-order) traversal of a forest. More...
|
class | filter_fullorder_iterator |
class | forest |
| A homogeneous hierarchical structure class. More...
|
class | format_base |
class | format_element_t |
class | generator_t |
| A function object for value generation within a domain. More...
|
struct | get_element |
struct | get_element< 0, pair< T1, T2 > > |
struct | get_element< 0, std::pair< T1, T2 > > |
struct | get_element< 1, pair< T1, T2 > > |
struct | get_element< 1, std::pair< T1, T2 > > |
struct | greater |
struct | greater_equal |
struct | has_type_type |
| is T::type a valid type (or a compile error?) More...
|
class | hash_index |
struct | identity |
struct | identity_element |
struct | identity_element< std::multiplies< T > > |
| specialization of identity_element for std::multiplies<T> More...
|
struct | identity_element< std::plus< T > > |
| specialization of identity_element for std::plus<T> More...
|
struct | inc |
| operator++ wrapped in a function object More...
|
class | indents |
class | index_iterator |
| An iterator over elements which are the result of applying a function to an index. More...
|
struct | indirect |
class | indirect_t |
| Adapter used to convert pointers to references. More...
|
struct | is_convertible |
struct | is_member |
struct | is_movable |
| The is_movable trait can be used to identify movable types. More...
|
struct | is_movable< copy_on_write< T, A > > |
struct | is_range |
| does T model the boost::range concepts? More...
|
struct | iter |
class | javascript_format |
class | layout_attributes_alignment_t |
| A utility class for referencing the alignment characteristics in layout_attributes_t. More...
|
struct | layout_attributes_placement_t |
class | layout_attributes_t |
| Layout data interface from the client to the engine. More...
|
struct | less |
struct | less_equal |
class | lex_stream_t |
struct | lex_token_t |
class | line_position_t |
| A type detailing parser position information. More...
|
struct | logical_and |
struct | logical_not |
struct | logical_or |
struct | logical_xor |
| xor funtion object More...
|
class | manipulator_base |
class | marshaled_exception |
class | md5_t |
| MD5 hash generator. More...
|
class | mem_data_t |
| Adaptor similar to boost::mem_fn() used by boost::bind . More...
|
struct | mem_data_t< const T, R > |
struct | move_from |
| move_from is used for move_ctors. More...
|
struct | move_sink |
| move_sink and copy_sink are used to select between overloaded operations according to whether type T is movable and convertible to type U. More...
|
class | my_class_t |
| A one-line synopsis of what the class does. More...
|
class | name_t |
| A character string class for immutable strings. More...
|
class | nearest_cast_fn |
struct | nearest_cast_fn< A, double > |
struct | nearest_cast_fn< A, float > |
struct | not_equal_to |
struct | null_output_iterator_t |
| A stub iterator that models OutputIterator and outputs nothing. More...
|
struct | optimized_storage_type |
| Authors of adobe::poly concept representatives must derive their instance class from this. See of adobe::poly_placeable_instance, for example. This metafunction is used in the implementation of the small storage optimization. More...
|
struct | pair |
class | pdf_format |
class | place_data_t |
| Layout data interface from the engine to the client. More...
|
struct | placeable |
| Representative of adobe::PlaceableConcept so that placeable models adobe::PlaceableConcept when T does. More...
|
struct | placeable_twopass |
struct | PlaceableConcept |
| Concept map and constraints checking for the Placeable concept. More...
|
struct | PlaceableConcept< T * > |
| Concept map and constraints checking for to allow boost::reference_wrapper<T> to model this concept when T does. More...
|
struct | PlaceableTwoPassConcept |
| Concept map and constraints checking for the PlaceableTwoPass concept. More...
|
struct | PlaceableTwoPassConcept< T * > |
| Concept map and constraints checking for to allow boost::reference_wrapper<T> to model this concept when T does. More...
|
struct | plus_asymmetric |
| plus function object whose arguments may be of different type. More...
|
struct | point_2d |
struct | pointer_to |
class | poly |
| adobe::poly<foo> will be a runtime polymorphic value type wrapper modelling a concept represented by foo More...
|
struct | poly_base |
| Authors of a Concept representative F, intended as a template parameter to adobe::poly, will inherit from adobe::poly_base. The first template parameter for adobe::poly_base provides the virtual interface for the concept representative. The second template parameter for adobe::poly_base must inherit from the Concept interface representative. The author's third duty is to provide forwarding functions in a their Concept representative. See the placeable_concept.hpp header file for details. More...
|
struct | poly_copyable_instance |
| Implementation of a trivial poly interface in terms of types modeling Copyable . Used in poly<copyable> implementation. More...
|
struct | poly_copyable_interface |
| Abstract interface providing signatures needed to implement "handle" objects modeling a Value (Copyable/Movable) concept. Authors of adobe::poly classes must derive their interfaces from this. See adobe::poly_placeable_interface for an example. More...
|
struct | poly_iterator_instance |
struct | poly_iterator_interface |
struct | poly_placeable_instance |
| Implementation of virtual interface for the poly<placeable> modeling adobe::PlaceableConcept. More...
|
struct | poly_placeable_interface |
| Pure virtual interface for the poly<placeable> modeling adobe::PlaceableConcept. More...
|
struct | poly_placeable_twopass_instance |
| Implementation of virtual interface for the poly<placeable_twopass> modeling adobe::PlaceableTwoPassConcept. More...
|
struct | poly_placeable_twopass_interface |
| Pure virtual interface for poly<placeable_twopass> modeling adobe::PlaceableTwoPassConcept. More...
|
struct | poly_regular_instance |
| Implementation of a trivial poly interface in terms of types modeling regular . Used in poly<regular> implementation. More...
|
struct | poly_regular_interface |
| Virtual interface for RegularConcept. Used in poly<regular> implementation. More...
|
class | promote |
| A struct for compile-time type promotion. More...
|
struct | promote< aggregate_name_t > |
struct | promote< const char * > |
struct | promote< float > |
struct | promote< int > |
struct | promote< long > |
struct | promote< short > |
struct | promote< static_name_t > |
struct | promote< std::string > |
struct | promote< unsigned int > |
struct | promote< unsigned long > |
struct | promote< unsigned short > |
struct | ptr_traits< auto_ptr< T, Traits > > |
struct | ptr_traits< auto_resource< T, Traits > > |
struct | ptr_traits< std::auto_ptr< T > > |
struct | ptr_traits< T * > |
| This section defines requirements on classes representing pointer traits. The template class ptr_traits< ptrT > is defined along with several specializations. More...
|
struct | ptr_traits< T(*)[]> |
struct | random_access_iter |
struct | regular |
| "Handle" class used in poly<regular> implementation. More...
|
struct | RegularConcept |
class | reverse_fullorder_cursor |
| An iterator-like type for reverse fullorder (pre- and post-order) traversal of a forest. More...
|
class | reverse_fullorder_iterator |
struct | runtime_cast_t |
struct | runtime_cast_t< R, any_regular_t * > |
struct | runtime_cast_t< R, any_regular_t > |
struct | runtime_cast_t< R, auto_ptr< T, Traits > > |
struct | runtime_cast_t< R, auto_resource< T, Traits > > |
struct | runtime_cast_t< R, const any_regular_t * > |
struct | runtime_cast_t< R, const any_regular_t > |
struct | runtime_cast_t< R, std::auto_ptr< T > > |
class | segmented_iterator |
struct | select |
class | selection_t |
| A container used to represent a linear boolean selection. More...
|
class | sequence_t |
| A function object for sequence generation within a domain. More...
|
struct | set_monitor_t |
| Adam support class. More...
|
class | sha1_t |
| A bit-oriented implementation of the SHA-1 Secure Hash Algorithm. More...
|
class | sha224_t |
| A bit-oriented implementation of the SHA-224 Secure Hash Algorithm. More...
|
class | sha256_t |
| A bit-oriented implementation of the SHA-256 Secure Hash Algorithm. More...
|
class | sha384_t |
| A bit-oriented implementation of the SHA-384 Secure Hash Algorithm. More...
|
class | sha512_t |
| A bit-oriented implementation of the SHA-512 Secure Hash Algorithm. More...
|
class | sheet_t |
| The fundamental data structure for the Property Model engine. More...
|
struct | short_name |
class | static_name_t |
| Utility wrapper to construct name_t with strings of static storage duration. More...
|
class | static_table |
| A simple lookup table of fixed size. [under review]. More...
|
class | static_table_traits |
| A traits class for use with adobe::static_table. More...
|
class | step_iterator_adaptor |
| step iterator adaptor More...
|
struct | str_less_t |
class | stream_error_t |
| An exception class thrown during parsing failures. More...
|
class | string16_t |
| Lightweight string class designed to hold UTF16 strings in fixed binary structure. More...
|
class | string_t |
| Lightweight string class designed to hold UTF8 strings in fixed binary structure. More...
|
class | table_index |
| Utility class for indexing objects based on specific member variable values. More...
|
class | timer_t |
struct | transposer |
struct | type_or_default |
struct | unary_compose |
struct | uuid_t |
class | value_iterator |
class | virtual_machine_t |
class | xml_format |
class | xml_parser_t |
| A relatively lightweight and simple xml (subset) parser. More...
|
class | xstring_context_t |
| Scope-based runtime context stack for glossary lookups. More...
|
class | zuid_t |
| UUID-like identifier generator. More...
|
Typedefs |
typedef version_1::any_regular_t | any_regular_t |
typedef version_1::vector
< any_regular_t > | array_t |
typedef boost::function
< eve_callback_suite_t::position_t(const
eve_callback_suite_t::position_t
&parent, name_t name,
dictionary_t arguments)> | bind_layout_proc_t |
typedef basic_bounded_width
< char, std::char_traits< char > > | bounded_width |
typedef version_1::closed_hash_map | closed_hash_map |
typedef version_1::closed_hash_set | closed_hash_set |
typedef
version1::closed_hash_map
< name_t, any_regular_t > | dictionary_t |
typedef std::vector< int > | guide_set_t |
typedef token_range_t( | implementation_xml_element_proc_t )(const token_range_t &entire_element_range, const token_range_t &name, const attribute_set_t &attribute_set, const token_range_t &value) |
typedef long | intptr_t |
typedef bool( | keyword_extension_lookup_proc_signature_t )(const name_t &) |
typedef boost::function
< keyword_extension_lookup_proc_signature_t > | keyword_extension_lookup_proc_t |
typedef boost::function
< std::string(const
std::string &)> | localization_lookup_proc_t |
typedef void_ * | null_ptr_t |
typedef bool | once_flag |
typedef std::pair< int, int > | pair_long_t |
typedef point_2d< int > | point_2d_t |
typedef poly< placeable > | poly_placeable_t |
typedef poly< placeable_twopass > | poly_placeable_twopass_t |
typedef pair< name_t,
any_regular_t > | stream_lex_token_t |
typedef struct thread_id_opaque_t * | thread_id_t |
typedef std::pair< uchar_ptr_t,
uchar_ptr_t > | token_range_t |
typedef const unsigned char * | uchar_ptr_t |
typedef unsigned long | uintptr_t |
typedef basic_bounded_width
< wchar_t, std::char_traits
< wchar_t > > | wbounded_width |
typedef boost::function
< implementation_xml_element_proc_t > | xml_element_proc_t |
Enumerations |
enum | { forest_trailing_edge,
forest_leading_edge
} |
enum | modifiers_t {
modifiers_none_s,
modifiers_left_shift_s,
modifiers_right_shift_s,
modifiers_left_option_s,
modifiers_right_option_s,
modifiers_left_control_s,
modifiers_right_control_s,
modifiers_caps_lock_s,
modifiers_any_command_s,
modifiers_any_shift_s,
modifiers_any_option_s,
modifiers_any_control_s,
modifiers_all_s
} |
enum | theme_t {
theme_none_s,
theme_large_s,
theme_normal_s,
theme_small_s,
theme_mini_s,
theme_adornment_label_s,
theme_adornment_number_s,
theme_adornment_mono_s,
theme_mask_s,
theme_adornment_mask_s,
theme_default_s
} |
Functions |
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) |
std::ostream & | operator<< (std::ostream &s, const extents_t &x) |
std::ostream & | operator<< (std::ostream &s, const extents_t::slice_t &x) |
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) |
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) |
std::ostream & | operator<< (std::ostream &, const line_position_t &) |
std::ostream & | operator<< (std::ostream &s, const token_range_t &x) |
template<typename T , class charT , class traits > |
std::basic_ostream< charT,
traits > & | operator<< (std::basic_ostream< charT, traits > &os, const begin_atom< T > &manip) |
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 > |
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) |
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) |
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) |
Variables |
aggregate_name_t | add_k |
static const aggregate_name_t | alt_name_g |
aggregate_name_t | and_k |
aggregate_name_t | array_k |
aggregate_name_t | assign_k |
aggregate_name_t | at_k |
static const aggregate_name_t | atom_name_g |
static const aggregate_name_t | bag_name_g |
aggregate_name_t | close_brace_k |
aggregate_name_t | close_bracket_k |
aggregate_name_t | close_parenthesis_k |
aggregate_name_t | colon_k |
aggregate_name_t | comma_k |
aggregate_name_t | dictionary_k |
aggregate_name_t | divide_k |
aggregate_name_t | dot_k |
aggregate_name_t | empty_k |
aggregate_name_t | eof_k |
aggregate_name_t | equal_k |
aggregate_name_t | false_k |
aggregate_name_t | function_k |
aggregate_name_t | greater_equal_k |
aggregate_name_t | greater_k |
aggregate_name_t | identifier_k |
aggregate_name_t | ifelse_k |
aggregate_name_t | index_k |
aggregate_name_t | is_k |
aggregate_name_t | keyword_k |
aggregate_name_t | lead_comment_k |
aggregate_name_t | less_equal_k |
aggregate_name_t | less_k |
aggregate_name_t | modulus_k |
aggregate_name_t | multiply_k |
aggregate_name_t | not_equal_k |
aggregate_name_t | not_k |
aggregate_name_t | number_k |
aggregate_name_t | open_brace_k |
aggregate_name_t | open_bracket_k |
aggregate_name_t | open_parenthesis_k |
aggregate_name_t | or_k |
aggregate_name_t | question_k |
aggregate_name_t | semicolon_k |
static const aggregate_name_t | seq_name_g |
aggregate_name_t | string_k |
aggregate_name_t | subtract_k |
aggregate_name_t | to_k |
aggregate_name_t | trail_comment_k |
aggregate_name_t | true_k |
aggregate_name_t | unary_negate_k |
aggregate_name_t | variable_k |
Compatibility |
Compatibility features for C99/TR1 <cmath> .
|
typedef Float | double_t |
typedef Float | float_t |
double | round (double x) |
float | round (float x) |
long | lround (double x) |
long | lround (float x) |
double | trunc (double x) |
float | trunc (float x) |