adobe Namespace Reference

Namespaces
namespace	arg_stream
namespace	dictionary_arg_stream_detail
namespace	fn
namespace	literals
namespace	unsafe
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
class	any_regular_t
	A runtime polymorphic type similar to boost::any which can hold any type which models Regular. More...
struct	asl_json_helper_t
	A utility class can be used with json_parser and json_generator to round trip JSON data through the common ASL data structures. More...
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_resource
	The template class auto_resource< X, Traits > provides similar functionality to unique_ptr for resources for which the pointer is opaque refered to by a non-pointer type. More...
class	bad_cast
	An exception class thrown during ASL failures to cast. More...
struct	binary_compose
struct	bitwise_and
struct	bitwise_or
struct	bitwise_xor
class	block_tag
class	cancellation_token
class	cancellation_token_source
class	capture_allocator
class	capture_allocator< void >
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	concurrent_queue
struct	constructor
class	contiguous_tag
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_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
struct	delete_ptr_trait< T * >
struct	delete_ptr_trait< T(*)[]>
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	empty_base
struct	empty_ptr
struct	empty_ptr< T * >
struct	empty_ptr< T(*)[]>
struct	empty_t
	An empty regular- and less-than-comparable- type. More...
struct	equal_to
struct	equivalent
struct	eve_callback_suite_t
class	eve_t
	Eve engine. More...
struct	expand_utf
class	expression_parser
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	F
class	filter_fullorder_iterator
class	forest
	A homogeneous hierarchical structure class. More...
class	function
class	generator_t
	A function object for value generation within a domain. More...
struct	get_element
struct	get_element< I, void >
struct	greater
struct	greater_equal
struct	has_stream_insertion
struct	has_type_type
	is T::type a valid type (or a compile error?) More...
class	hash_index
struct	identity
struct	identity< void >
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	index_iterator
	An iterator over elements which are the result of applying a function to an index. More...
struct	indirect
struct	is_base_derived_or_same
struct	is_member
struct	is_range
	does T model the boost::range concepts? More...
class	json_generator
	A utility class that uses a helper class to access a provided data structure and output well-formed JSON. More...
class	json_parser
	A utility class that parses raw JSON data and uses a helper class to construct the desired representations of what is parsed. More...
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	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	marshaled_exception
class	md5_t
	MD5 hash generator. More...
class	mem_data_t
	Adaptor similar to boost::mem_fn() used by std::bind. More...
struct	mem_data_t< const T, R >
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	new_delete_t
class	node_tag
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 poly concept representatives must derive their instance class from this. See of poly_placeable_instance, for example. This metafunction is used in the implementation of the small storage optimization. More...
class	place_data_t
	Layout data interface from the engine to the client. More...
struct	placeable
	Representative of PlaceableConcept so that placeable models 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 std::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 std::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
	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 poly, will inherit from poly_base. The first template parameter for poly_base provides the virtual interface for the concept representative. The second template parameter for 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 poly classes must derive their interfaces from this. See poly_placeable_interface for an example. More...
struct	poly_placeable_instance
	Implementation of virtual interface for the poly<placeable> modeling PlaceableConcept. More...
struct	poly_placeable_interface
	Pure virtual interface for the poly<placeable> modeling PlaceableConcept. More...
struct	poly_placeable_twopass_instance
	Implementation of virtual interface for the poly<placeable_twopass> modeling PlaceableTwoPassConcept. More...
struct	poly_placeable_twopass_interface
	Pure virtual interface for poly<placeable_twopass> modeling 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< const char * >
struct	promote< static_name_t >
struct	ptr_traits
struct	ptr_traits< T * >
	The ptr_traits class provide basic information and operations associated with a pointer type. More...
struct	ptr_traits< T(*)[]>
struct	regular
	"Handle" class used in poly<regular> implementation. More...
struct	RegularConcept
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, const any_regular_t * >
struct	runtime_cast_t< R, const any_regular_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...
class	serializable_t
struct	serialize
struct	serialize< std::reference_wrapper< T > >
struct	set_monitor_t
	Adam support class. More...
class	sha
class	shared_task_queue
class	sheet_t
	The fundamental data structure for the Property Model engine. More...
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	storage_category
struct	storage_category< std::deque< T, A > >
struct	storage_category< std::list< T, A > >
struct	storage_category< std::map< K, T, C, A > >
struct	storage_category< std::multimap< K, T, C, A > >
struct	storage_category< std::multiset< T, C, A > >
struct	storage_category< std::set< T, C, A > >
struct	storage_category< std::vector< T, A > >
struct	str_equal_to_t
struct	str_less_t
class	stream_error_t
	An exception class thrown during parsing failures. More...
class	table_index
	Utility class for indexing objects based on specific member variable values. More...
class	task_canceled
class	timer_t
struct	transpose
struct	type_or_default
struct	typeid_
	typeid(x) wrapped in a function object More...
struct	unary_compose
struct	uuid_t
class	value_iterator
class	vector
class	virtual_machine_t
	Stack-based non-branching expression evaluator. More...
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 std::vector< any_regular_t >	array_t
template<class T>
using	promote_t
template<class T>
using	copy_on_write
typedef closed_hash_map< name_t, any_regular_t >	dictionary_t
using	bind_layout_proc_t
typedef std::pair< int, int >	pair_long_t
typedef point_2d< int >	point_2d_t
typedef std::vector< int >	guide_set_t
template<std::size_t Bits>
using	fnv_traits
template<std::size_t Bits>
using	fnvtype
typedef void_ *	null_ptr_t
template<std::size_t I, class T>
using	element
	Deprecated, use std::tuple_element instead.
using	localization_lookup_proc_t
typedef poly< copyable >	poly_copyable_t
typedef poly< placeable >	poly_placeable_t
	convenience typedef.
typedef poly< placeable_twopass >	poly_placeable_twopass_t
	convenience typedef.
typedef poly< regular >	poly_regular_t
template<class T>
using	has_ostream_insertion
typedef sha< implementation::sha1_traits_t >	sha1_t
	A bit-oriented implementation of the SHA-1 Secure Hash Algorithm.
typedef sha< implementation::sha224_traits_t >	sha224_t
	A bit-oriented implementation of the SHA-224 Secure Hash Algorithm.
typedef sha< implementation::sha256_traits_t >	sha256_t
	A bit-oriented implementation of the SHA-256 Secure Hash Algorithm.
typedef sha< implementation::sha384_traits_t >	sha384_t
	A bit-oriented implementation of the SHA-384 Secure Hash Algorithm.
typedef sha< implementation::sha512_traits_t >	sha512_t
	A bit-oriented implementation of the SHA-512 Secure Hash Algorithm.
typedef std::function< void()> *	cancellation_token_registration
typedef const struct thread_id_opaque_t *	thread_id_t
template<class F, class... Args>
using	invoke_result_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)
using	xml_element_proc_t

Enumerations
enum	{ forest_trailing_edge , forest_leading_edge }
enum class	json_type {   object , array , string , number ,   boolean , null }
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 }
	Semantic theme settings to apply to a widget. More...
enum	modifiers_t : std::uint32_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 }
	Standard keyboard state modifiers. More...

Functions
adam_callback_suite_t	bind_to_sheet (sheet_t &)
adam_callback_suite_t	bind_to_sheet (sheet_t &, external_model_t &)
void	parse (std::istream &stream, const line_position_t &position, const adam_callback_suite_t &callbacks)
array_t	parse_adam_expression (const std::string &expression)
template<class T, class R>
auto	append (T &c, const R &r)
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< std::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< std::is_same< I, T >, boost::range_const_iterator< I > >::type	binary_search (const I &r, const T &x, C c, P p)
template<typename T, typename R>
const T &	clamp (const T &x, const T &min, const T &max, R r)
	clamp implementation
template<typename T, typename R>
T &	clamp (T &x, T &min, T &max, R r)
	clamp implementation
template<typename T>
const T &	clamp (const T &x, const T &min, const T &max)
	clamp implementation
template<typename T>
T &	clamp (T &x, T &min, T &max)
	clamp implementation
template<typename T, typename R>
const T &	clamp_unordered (const T &x, const T &min, const T &max, R r)
	clamp_unordered implementation
template<typename T, typename R>
T &	clamp_unordered (T &x, T &min, T &max, R r)
	clamp_unordered implementation
template<typename T>
const T &	clamp_unordered (const T &x, const T &min, const T &max)
	clamp_unordered implementation
template<typename T>
T &	clamp_unordered (T &x, T &min, T &max)
	clamp_unordered implementation
template<class InputRange, class OutputIterator>
OutputIterator	copy (const InputRange &range, OutputIterator result)
	copy implementation
template<class BidirectionalRange1, class BidirectionalIterator2>
BidirectionalIterator2	copy_backward (BidirectionalRange1 &range1, BidirectionalIterator2 result)
	copy implementation
template<class BidirectionalRange1, class BidirectionalIterator2>
BidirectionalIterator2	copy_backward (const BidirectionalRange1 &range1, BidirectionalIterator2 result)
	copy implementation
template<class InputIter, class Size, class OutputIter>
std::pair< InputIter, OutputIter >	copy_n (InputIter first, Size count, OutputIter result)
	copy implementation
template<typename I, typename F>
std::pair< I, F >	copy_bounded (I first, I last, F result_first, F result_last)
	copy implementation
template<typename I, typename O, typename T>
std::pair< I, O >	copy_sentinal (I f, O o, const T &x)
	copy implementation
template<typename I, typename O>
std::pair< I, O >	copy_sentinal (I f, O o)
	copy implementation
template<class InputRange, class T>
boost::range_difference< InputRange >::type	count (InputRange &range, T &value)
	count implementation
template<class InputRange, class T>
boost::range_difference< InputRange >::type	count (const InputRange &range, T &value)
	count implementation
template<class InputIterator, class Predicate>
std::iterator_traits< InputIterator >::difference_type	count_if (InputIterator first, InputIterator last, Predicate pred)
	count implementation
template<class InputRange, class Predicate>
boost::range_difference< InputRange >::type	count_if (InputRange &range, Predicate pred)
	count implementation
template<class InputRange, class Predicate>
boost::range_difference< InputRange >::type	count_if (const InputRange &range, Predicate pred)
	count implementation
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 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 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< std::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< std::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< std::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< std::is_same< I, T >, implementation::lazy_range_const< I > >::type	equal_range (const I &r, const T &x, C c)
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<class ForwardRange, class T>
void	fill (ForwardRange &range, const T &value)
	fill implementation
template<typename I, typename O, typename F>
O	filter (I first, I last, O result, F op)
	filter implementation
template<typename I, typename O, typename F>
O	filter (I &source, O result, F op)
	filter implementation
template<typename I, typename O, typename F>
O	filter (const I &source, O result, F op)
	filter implementation
template<class InputIterator, class Predicate>
InputIterator	find_if_not (InputIterator first, InputIterator last, Predicate pred)
	find_if_not implementation
template<class InputRange, class Predicate>
boost::range_iterator< InputRange >::type	find_if_not (InputRange &range, Predicate pred)
	find_if_not implementation
template<class InputRange, class Predicate>
boost::range_const_iterator< InputRange >::type	find_if_not (const InputRange &range, Predicate pred)
	find_if_not implementation
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)
	find_not implementation
template<class InputRange, class T>
boost::range_const_iterator< InputRange >::type	find_not (const InputRange &range, const T &value)
	find_not implementation
template<class InputRange, class T>
boost::range_iterator< InputRange >::type	find (InputRange &range, const T &value)
	find implementation
template<class InputRange, class T>
boost::range_const_iterator< InputRange >::type	find (const InputRange &range, const T &value)
	find implementation
template<class InputIterator, class Predicate>
InputIterator	find_if (InputIterator first, InputIterator last, Predicate pred)
	find implementation
template<class InputRange, class Predicate>
boost::range_iterator< InputRange >::type	find_if (InputRange &range, Predicate pred)
	find implementation
template<class InputRange, class Predicate>
boost::range_const_iterator< InputRange >::type	find_if (const InputRange &range, Predicate pred)
	find implementation
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 ForwardRange1, class ForwardRange2>
boost::range_iterator< ForwardRange1 >::type	find_end (ForwardRange1 &range1, const ForwardRange2 &range2)
	find implementation
template<class ForwardRange1, class ForwardRange2>
boost::range_const_iterator< ForwardRange1 >::type	find_end (const ForwardRange1 &range1, const ForwardRange2 &range2)
	find implementation
template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
ForwardIterator1	find_end (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate comp)
	find implementation
template<class ForwardRange1, class ForwardRange2, class BinaryPredicate>
boost::range_iterator< ForwardRange1 >::type	find_end (ForwardRange1 &range1, const ForwardRange2 &range2, BinaryPredicate comp)
	find implementation
template<class ForwardRange1, class ForwardRange2, class BinaryPredicate>
boost::range_const_iterator< ForwardRange1 >::type	find_end (const ForwardRange1 &range1, const ForwardRange2 &range2, BinaryPredicate comp)
	find implementation
template<class ForwardRange>
boost::range_iterator< ForwardRange >::type	adjacent_find (ForwardRange &range)
	find implementation
template<class ForwardRange>
boost::range_const_iterator< ForwardRange >::type	adjacent_find (const ForwardRange &range)
	find implementation
template<class ForwardIterator, class BinaryPredicate>
ForwardIterator	adjacent_find (ForwardIterator first, ForwardIterator last, BinaryPredicate pred)
	find implementation
template<class ForwardRange, class BinaryPredicate>
boost::range_iterator< ForwardRange >::type	adjacent_find (ForwardRange &range, BinaryPredicate pred)
	find implementation
template<class ForwardRange, class BinaryPredicate>
boost::range_const_iterator< ForwardRange >::type	adjacent_find (const ForwardRange &range, BinaryPredicate pred)
	find implementation
template<class InputIterator, class T, class Compare>
InputIterator	find_match (InputIterator first, InputIterator last, const T &value, Compare comp)
	find_match implementation
template<class InputRange, class T, class Compare>
boost::range_iterator< InputRange >::type	find_match (InputRange &range, const T &value, Compare comp)
	find_match implementation
template<class InputRange, class T, class Compare>
boost::range_const_iterator< InputRange >::type	find_match (const InputRange &range, const T &value, Compare comp)
	find_match implementation
template<class InputIterator, class T, class Compare>
InputIterator	find_match (InputIterator first, InputIterator last, const T &value)
	find_match implementation
template<class InputRange, class T, class Compare>
boost::range_iterator< InputRange >::type	find_match (InputRange &range, const T &value)
	find_match implementation
template<class InputRange, class T, class Compare>
boost::range_const_iterator< InputRange >::type	find_match (const InputRange &range, const T &value)
	find_match implementation
template<class InputIterator, class UnaryFunction>
void	for_each (InputIterator first, InputIterator last, UnaryFunction f)
	for_each implementation
template<class InputRange, class UnaryFunction>
void	for_each (InputRange &range, UnaryFunction f)
	for_each implementation
template<class InputRange, class UnaryFunction>
void	for_each (const InputRange &range, UnaryFunction f)
	for_each implementation
template<class InputIterator, class UnaryFunction>
void	for_each_position (InputIterator first, InputIterator last, UnaryFunction f)
	for_each_position implementation
template<class InputRange, class UnaryFunction>
void	for_each_position (InputRange &range, UnaryFunction f)
	for_each_position implementation
template<class InputRange, class UnaryFunction>
void	for_each_position (const InputRange &range, UnaryFunction f)
	for_each_position implementation
template<typename Iter, typename Pred>
std::pair< Iter, Iter >	gather (Iter first, Iter last, Iter pivot, Pred pred)
	iterator-based gather implementation
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)
	range-based gather implementation
template<class ForwardRange, class Generator>
void	generate (ForwardRange &range, Generator gen)
	generate implementation
template<class RandomAccessRange>
void	push_heap (RandomAccessRange &range)
	heap implementation
template<class RandomAccessIterator, class Compare>
void	push_heap (RandomAccessIterator first, RandomAccessIterator last, Compare comp)
	heap implementation
template<class RandomAccessRange, class Compare>
void	push_heap (RandomAccessRange &range, Compare comp)
	heap implementation
template<class RandomAccessRange>
void	pop_heap (RandomAccessRange &range)
	heap implementation
template<class RandomAccessIterator, class Compare>
void	pop_heap (RandomAccessIterator first, RandomAccessIterator last, Compare comp)
	heap implementation
template<class RandomAccessRange, class Compare>
void	pop_heap (RandomAccessRange &range, Compare comp)
	heap implementation
template<class RandomAccessRange>
void	make_heap (RandomAccessRange &range)
	heap implementation
template<class RandomAccessIterator, class Compare>
void	make_heap (RandomAccessIterator first, RandomAccessIterator last, Compare comp)
	heap implementation
template<class RandomAccessRange, class Compare>
void	make_heap (RandomAccessRange &range, Compare comp)
	heap implementation
template<class RandomAccessRange>
void	sort_heap (RandomAccessRange &range)
	heap implementation
template<class RandomAccessIterator, class Compare>
void	sort_heap (RandomAccessIterator first, RandomAccessIterator last, Compare comp)
	heap implementation
template<class RandomAccessRange, class Compare>
void	sort_heap (RandomAccessRange &range, Compare comp)
	heap implementation
template<class ForwardIterator, class T>
T	iota (ForwardIterator first, ForwardIterator last, const T &value)
	iota implementation
template<class ForwardRange, class T>
T	iota (ForwardRange &range, const T &value)
	iota implementation
template<class InputRange1, class InputRange2>
bool	lexicographical_compare (const InputRange1 &range1, const InputRange2 &range2)
	lexicographical_compare implementation
template<class InputIterator1, class InputIterator2, class Compare>
bool	lexicographical_compare (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, Compare comp)
	lexicographical_compare implementation
template<class InputRange1, class InputRange2, class Compare>
bool	lexicographical_compare (const InputRange1 &range1, const InputRange2 &range2, Compare comp)
	lexicographical_compare implementation
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)
template<typename T, typename R>
const T &	median (const T &a, const T &b, const T &c, R r)
	median implementation
template<typename T, typename R>
T &	median (T &a, T &b, T &c, R r)
	median implementation
template<typename T>
const T &	median (const T &a, const T &b, const T &c)
	median implementation
template<typename T>
T &	median (T &a, T &b, T &c)
	median implementation
template<class InputRange1, class InputRange2, class OutputIterator>
OutputIterator	merge (const InputRange1 &range1, const InputRange2 &range2, OutputIterator result)
	merge implementation
template<class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
OutputIterator	merge (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp)
	merge implementation
template<class InputRange1, class InputRange2, class OutputIterator, class Compare>
OutputIterator	merge (const InputRange1 &range1, const InputRange2 &range2, OutputIterator result, Compare comp)
	merge implementation
template<class T, class R>
const T &	min (const T &a, const T &b, R r)
	minmax implementation
template<class T, class R>
T &	min (T &a, T &b, R r)
	minmax implementation
template<class T>
const T &	min (const T &a, const T &b)
	minmax implementation
template<class T>
T &	min (T &a, T &b)
	minmax implementation
template<class T, class R>
const T &	max (const T &a, const T &b, R r)
	minmax implementation
template<class T, class R>
T &	max (T &a, T &b, R r)
	minmax implementation
template<class T>
const T &	max (const T &a, const T &b)
	minmax implementation
template<class T>
T &	max (T &a, T &b)
	minmax implementation
template<class ForwardRange>
boost::range_iterator< ForwardRange >::type	min_element (ForwardRange &range)
	minmax implementation
template<class ForwardRange>
boost::range_const_iterator< ForwardRange >::type	min_element (const ForwardRange &range)
	minmax implementation
template<class ForwardIterator, class R>
ForwardIterator	min_element (ForwardIterator first, ForwardIterator last, R r)
	minmax implementation
template<class ForwardRange, class R>
boost::range_iterator< ForwardRange >::type	min_element (ForwardRange &range, R r)
	minmax implementation
template<class ForwardRange, class R>
boost::range_const_iterator< ForwardRange >::type	min_element (const ForwardRange &range, R r)
	minmax implementation
template<class ForwardRange>
boost::range_iterator< ForwardRange >::type	max_element (ForwardRange &range)
	minmax implementation
template<class ForwardRange>
boost::range_const_iterator< ForwardRange >::type	max_element (const ForwardRange &range)
	minmax implementation
template<class ForwardIterator, class R>
ForwardIterator	max_element (ForwardIterator first, ForwardIterator last, R r)
	minmax implementation
template<class ForwardRange, class R>
boost::range_iterator< ForwardRange >::type	max_element (ForwardRange &range, R r)
	minmax implementation
template<class ForwardRange, class R>
boost::range_const_iterator< ForwardRange >::type	max_element (const ForwardRange &range, R r)
	minmax implementation
template<class InputRange1, class InputIterator2>
std::pair< typename boost::range_iterator< InputRange1 >::type, InputIterator2 >	mismatch (InputRange1 &range1, InputIterator2 first2)
	mismatch implementation
template<class InputRange1, class InputIterator2>
std::pair< typename boost::range_const_iterator< InputRange1 >::type, InputIterator2 >	mismatch (const InputRange1 &range1, InputIterator2 first2)
	mismatch implementation
template<class InputIterator1, class InputIterator2, class BinaryPredicate>
std::pair< InputIterator1, InputIterator2 >	mismatch (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, BinaryPredicate pred)
	mismatch implementation
template<class InputRange1, class InputIterator2, class BinaryPredicate>
std::pair< typename boost::range_iterator< InputRange1 >::type, InputIterator2 >	mismatch (InputRange1 &range1, InputIterator2 first2, BinaryPredicate pred)
	mismatch implementation
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)
	mismatch implementation
template<typename T, typename P, typename BinaryPredicate>
const T &	other_of (const P &pair, const T &x, BinaryPredicate pred)
	other_of implementation
template<typename T, typename P>
const T &	other_of (const P &pair, const T &x)
	other_of implementation
template<class BidirectionalIterator, class Predicate>
BidirectionalIterator	partition (BidirectionalIterator first, BidirectionalIterator last, Predicate pred)
	partition implementation
template<class BidirectionalRange, class Predicate>
boost::range_iterator< BidirectionalRange >::type	partition (BidirectionalRange &range, Predicate pred)
	partition implementation
template<class BidirectionalIterator, class Predicate>
BidirectionalIterator	stable_partition (BidirectionalIterator first, BidirectionalIterator last, Predicate pred)
	partition implementation
template<class BidirectionalRange, class Predicate>
boost::range_iterator< BidirectionalRange >::type	stable_partition (BidirectionalRange &range, Predicate pred)
	partition implementation
template<class BidirectionalRange>
bool	next_permutation (BidirectionalRange &range)
	permutation implementation
template<class BidirectionalIterator, class Compare>
bool	next_permutation (BidirectionalIterator first, BidirectionalIterator last, Compare comp)
	permutation implementation
template<class BidirectionalRange, class Compare>
bool	next_permutation (BidirectionalRange &range, Compare comp)
	permutation implementation
template<class BidirectionalRange>
bool	prev_permutation (BidirectionalRange &range)
	permutation implementation
template<class BidirectionalIterator, class Compare>
bool	prev_permutation (BidirectionalIterator first, BidirectionalIterator last, Compare comp)
	permutation implementation
template<class BidirectionalRange, class Compare>
bool	prev_permutation (BidirectionalRange &range, Compare comp)
	permutation implementation
template<typename T, typename R>
const T &	pin (const T &min, const T &x, const T &max, R r)
	pin implementation
template<typename T>
const T &	pin (const T &min, const T &x, const T &max)
	pin implementation
template<typename T, typename R>
const T &	pin_safe (const T &min, const T &x, const T &max, R r)
	pin_safe implementation
template<typename T, typename R>
const T &	pin_safe (const T &min, const T &x, const T &max)
	pin_safe implementation
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 >()())
	reduce implementation
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 >()())
	reduce implementation
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 >()())
	reduce implementation
template<class InputRange, class T>
boost::range_iterator< InputRange >::type	remove (InputRange &range, const T &value)
	remove implementation
template<class InputIterator, class Predicate>
InputIterator	remove_if (InputIterator first, InputIterator last, Predicate pred)
	remove implementation
template<class InputRange, class Predicate>
boost::range_iterator< InputRange >::type	remove_if (InputRange &range, Predicate pred)
	remove implementation
template<class InputRange, class OutputIterator, class T>
boost::range_iterator< InputRange >::type	remove_copy (InputRange &range, OutputIterator result, const T &value)
	remove implementation
template<class InputRange, class OutputIterator, class T>
boost::range_const_iterator< InputRange >::type	remove_copy (const InputRange &range, OutputIterator result, const T &value)
	remove implementation
template<class InputIterator, class OutputIterator, class Predicate>
InputIterator	remove_copy_if (InputIterator first, InputIterator last, OutputIterator result, Predicate pred)
	remove implementation
template<class InputRange, class OutputIterator, class Predicate>
boost::range_iterator< InputRange >::type	remove_copy_if (InputRange &range, OutputIterator result, Predicate pred)
	remove implementation
template<class InputRange, class OutputIterator, class Predicate>
boost::range_const_iterator< InputRange >::type	remove_copy_if (const InputRange &range, OutputIterator result, Predicate pred)
	remove implementation
template<class ForwardRange, class T>
void	replace (ForwardRange &range, const T &old_value, const T &new_value)
	replace implementation
template<class ForwardIterator, class Predicate, class T>
void	replace_if (ForwardIterator first, ForwardIterator last, Predicate pred, const T &new_value)
	replace implementation
template<class ForwardRange, class Predicate, class T>
void	replace_if (ForwardRange &range, Predicate pred, const T &new_value)
	replace implementation
template<class ForwardRange, class OutputIterator, class T>
OutputIterator	replace_copy (ForwardRange &range, OutputIterator result, const T &old_value, const T &new_value)
	replace implementation
template<class ForwardRange, class OutputIterator, class T>
OutputIterator	replace_copy (const ForwardRange &range, OutputIterator result, const T &old_value, const T &new_value)
	replace implementation
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)
	replace implementation
template<class ForwardRange, class OutputIterator, class Predicate, class T>
OutputIterator	replace_copy_if (ForwardRange &range, OutputIterator result, Predicate pred, const T &new_value)
	replace implementation
template<class ForwardRange, class OutputIterator, class Predicate, class T>
OutputIterator	replace_copy_if (const ForwardRange &range, OutputIterator result, Predicate pred, const T &new_value)
	replace implementation
template<class BidirectionalRange>
void	reverse (BidirectionalRange &range)
	reverse implementation
template<class BidirectionalRange, class OutputIterator>
void	reverse_copy (BidirectionalRange &range, OutputIterator result)
	reverse implementation
template<class BidirectionalRange, class OutputIterator>
void	reverse_copy (const BidirectionalRange &range, OutputIterator result)
	reverse implementation
template<typename I>
std::pair< I, I >	reverse_until (I f, I m, I l)
	reverse implementation
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)
template<class ForwardRange1, class ForwardRange2>
boost::range_const_iterator< ForwardRange1 >::type	search (const ForwardRange1 &range1, const ForwardRange2 &range2)
	search implementation
template<class ForwardRange1, class ForwardRange2>
boost::range_iterator< ForwardRange1 >::type	search (ForwardRange1 &range1, const ForwardRange2 &range2)
	search implementation
template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
ForwardIterator1	search (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred)
	search implementation
template<class ForwardRange1, class ForwardRange2, class BinaryPredicate>
boost::range_iterator< ForwardRange1 >::type	search (ForwardRange1 &range1, const ForwardRange2 &range2, BinaryPredicate pred)
	search implementation
template<class ForwardRange1, class ForwardRange2, class BinaryPredicate>
boost::range_const_iterator< ForwardRange1 >::type	search (const ForwardRange1 &range1, const ForwardRange2 &range2, BinaryPredicate pred)
	search implementation
template<class ForwardRange, class Size, class T>
boost::range_iterator< ForwardRange >::type	search_n (ForwardRange &range, Size count, const T &value)
	search implementation
template<class ForwardRange, class Size, class T>
boost::range_const_iterator< ForwardRange >::type	search_n (const ForwardRange &range, Size count, const T &value)
	search implementation
template<class ForwardIterator, class Size, class T, class BinaryPredicate>
ForwardIterator	search_n (ForwardIterator first, ForwardIterator last, Size count, const T &value, BinaryPredicate pred)
	search implementation
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)
	search implementation
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)
	search implementation
template<class T, class R>
const T &	select_0_2 (const T &a, const T &b, R r)
	select_0 implementation
template<class T, class R>
T &	select_0_2 (T &a, T &b, R r)
	select_0 implementation
template<class T, class R>
const T &	select_1_2 (const T &a, const T &b, R r)
	select_0 implementation
template<class T, class R>
T &	select_1_2 (T &a, T &b, R r)
	select_0 implementation
template<typename T, typename R>
const T &	select_1_3_ac (const T &a, const T &b, const T &c, R r)
	select_1_ab implementation
template<typename T, typename R>
T &	select_1_3_ac (T &a, T &b, T &c, R r)
	select_1_ab implementation
template<typename T, typename R>
const T &	select_1_3_ab (const T &a, const T &b, const T &c, R r)
	select_1_ab implementation
template<typename T, typename R>
T &	select_1_3_ab (T &a, T &b, T &c, R r)
	select_1_ab implementation
template<typename T, typename R>
const T &	select_1_3 (const T &a, const T &b, const T &c, R r)
	select_1 implementation
template<typename T, typename R>
T &	select_1_3 (T &a, T &b, T &c, R r)
	select_1 implementation
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 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)
	selection_operation implementation
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)
	selection_union implementation
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)
	selection_intersection implementation
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)
	selection_difference implementation
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)
	selection_symmetric_difference implementation
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)
	selection_includes implementation
template<typename Selection1, typename Selection2>
Selection1	selection_intersection (const Selection1 &x, const Selection2 &y)
	selection_intersection implementation
template<typename Selection1, typename Selection2>
Selection1	selection_union (const Selection1 &x, const Selection2 &y)
	selection_union implementation
template<typename Selection1, typename Selection2>
Selection1	selection_difference (const Selection1 &x, const Selection2 &y)
	selection_difference implementation
template<typename Selection1, typename Selection2>
Selection1	selection_symmetric_difference (const Selection1 &x, const Selection2 &y)
	selection_symmetric_difference implementation
template<typename Selection1, typename Selection2>
bool	selection_includes (const Selection1 &x, const Selection2 &y)
	selection_includes implementation
template<typename Selection>
void	invert (Selection &x)
	invert implementation
template<typename Selection>
bool	start_selected (const Selection &x)
	start_selected implementation
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<typename Selection>
bool	is_selected (const Selection &x, typename Selection::value_type index)
template<typename Selection, typename ForwardRange, typename OutputIterator>
OutputIterator	selection_copy (const Selection &x, const ForwardRange &range, OutputIterator output)
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)
	selection_partition_copy implementation
template<typename Selection, typename ForwardRange, typename UnaryFunction>
UnaryFunction	selection_foreach (const Selection &x, const ForwardRange &range, UnaryFunction proc)
	selection_foreach implementation
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 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 I, typename N>
std::pair< I, N >	find_sequence_end (I f, I l, N n)
template<typename I, typename O>
void	index_set_to_selection (I f, I l, O output)
template<typename Selection, typename ForwardRange>
Selection	index_set_to_selection (const ForwardRange &index_set)
template<typename Selection, typename OutputIterator>
OutputIterator	selection_to_index_set (const Selection &selection, typename boost::range_size< Selection >::type max_index, OutputIterator output)
template<class InputRange1, class InputRange2>
bool	includes (const InputRange1 &range1, const InputRange2 &range2)
	set implementation
template<class InputIterator1, class InputIterator2, class Compare>
bool	includes (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, Compare comp)
	set implementation
template<class InputRange1, class InputRange2, class Compare>
bool	includes (const InputRange1 &range1, const InputRange2 &range2, Compare comp)
	set implementation
template<class InputRange1, class InputRange2, class OutputIterator>
OutputIterator	set_union (const InputRange1 &range1, const InputRange2 &range2, OutputIterator result)
	set implementation
template<class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
OutputIterator	set_union (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp)
	set implementation
template<class InputRange1, class InputRange2, class OutputIterator, class Compare>
OutputIterator	set_union (const InputRange1 &range1, const InputRange2 &range2, OutputIterator result, Compare comp)
	set implementation
template<class InputRange1, class InputRange2, class OutputIterator>
OutputIterator	set_intersection (const InputRange1 &range1, const InputRange2 &range2, OutputIterator result)
	set implementation
template<class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
OutputIterator	set_intersection (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp)
	set implementation
template<class InputRange1, class InputRange2, class OutputIterator, class Compare>
OutputIterator	set_intersection (const InputRange1 &range1, const InputRange2 &range2, OutputIterator result, Compare comp)
	set implementation
template<class InputRange1, class InputRange2, class OutputIterator>
OutputIterator	set_difference (const InputRange1 &range1, const InputRange2 &range2, OutputIterator result)
	set implementation
template<class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
OutputIterator	set_difference (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp)
	set implementation
template<class InputRange1, class InputRange2, class OutputIterator, class Compare>
OutputIterator	set_difference (const InputRange1 &range1, const InputRange2 &range2, OutputIterator result, Compare comp)
	set implementation
template<class InputRange1, class InputRange2, class OutputIterator>
OutputIterator	set_symmetric_difference (const InputRange1 &range1, const InputRange2 &range2, OutputIterator result)
	set implementation
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)
	set implementation
template<class InputRange1, class InputRange2, class OutputIterator, class Compare>
OutputIterator	set_symmetric_difference (const InputRange1 &range1, const InputRange2 &range2, OutputIterator result, Compare comp)
	set implementation
template<class RandomAccessRange>
void	sort (RandomAccessRange &range)
	sort implementation
template<class RandomAccessIterator, class Compare>
void	sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp)
	sort implementation
template<typename I, typename C, typename P>
void	sort (I f, I l, C c, P p)
	sort implementation
template<typename R, typename C, typename P>
void	sort (R &r, C c, P p)
	sort implementation
template<class RandomAccessRange, class Compare>
void	sort (RandomAccessRange &range, Compare comp)
	sort implementation
template<class RandomAccessRange>
void	stable_sort (RandomAccessRange &range)
	sort implementation
template<class RandomAccessIterator, class Compare>
void	stable_sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp)
	sort implementation
template<class RandomAccessRange, class Compare>
void	stable_sort (RandomAccessRange &range, Compare comp)
	sort implementation
template<class InputRange, class RandomAccessRange>
void	partial_sort_copy (InputRange &range, RandomAccessRange &result_range)
	sort implementation
template<class InputRange, class RandomAccessRange>
void	partial_sort_copy (const InputRange &range, RandomAccessRange &result_range)
	sort implementation
template<class InputIterator, class RandomAccessIterator, class Compare>
void	partial_sort_copy (InputIterator first, InputIterator last, RandomAccessIterator result_first, RandomAccessIterator result_last, Compare comp)
	sort implementation
template<class InputRange, class RandomAccessRange, class Compare>
void	partial_sort_copy (InputRange &range, RandomAccessRange &result_range, Compare comp)
	sort implementation
template<class InputRange, class RandomAccessRange, class Compare>
void	partial_sort_copy (const InputRange &range, RandomAccessRange &result_range, Compare comp)
	sort implementation
template<typename I, typename O>
I	sorted (I f, I l, O o)
template<typename I>
I	sorted (I f, I l)
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)
template<class ForwardRange1, class ForwardIterator2>
ForwardIterator2	swap_ranges (ForwardRange1 &range1, ForwardIterator2 first2)
	swap_ranges implementation
template<class InputIterator, class OutputIterator, class UnaryOperation>
OutputIterator	transform (InputIterator first, InputIterator last, OutputIterator result, UnaryOperation op)
	transform implementation
template<class InputRange, class OutputIterator, class UnaryOperation>
OutputIterator	transform (InputRange &range, OutputIterator result, UnaryOperation op)
	transform implementation
template<class InputRange, class OutputIterator, class UnaryOperation>
OutputIterator	transform (const InputRange &range, OutputIterator result, UnaryOperation op)
	transform implementation
template<class InputIterator1, class InputIterator2, class OutputIterator, class BinaryOperation>
OutputIterator	transform (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, BinaryOperation binary_op)
	transform implementation
template<class InputRange1, class InputIterator2, class OutputIterator, class BinaryOperation>
OutputIterator	transform (InputRange1 &range1, InputIterator2 first2, OutputIterator result, BinaryOperation binary_op)
	transform implementation
template<class InputRange1, class InputIterator2, class OutputIterator, class BinaryOperation>
OutputIterator	transform (const InputRange1 &range1, InputIterator2 first2, OutputIterator result, BinaryOperation binary_op)
	transform implementation
template<class ForwardRange>
auto	unique (ForwardRange &range)
	unique implementation
template<class ForwardIterator, class BinaryPredicate>
ForwardIterator	unique (ForwardIterator first, ForwardIterator last, BinaryPredicate pred)
	unique implementation
template<class ForwardRange, class BinaryPredicate>
auto	unique (ForwardRange &range, BinaryPredicate pred)
	unique implementation
template<class InputRange, class OutputIterator>
OutputIterator	unique_copy (InputRange &range, OutputIterator result)
	unique implementation
template<class InputRange, class OutputIterator>
OutputIterator	unique_copy (const InputRange &range, OutputIterator result)
	unique implementation
template<class InputIterator, class OutputIterator, class BinaryPredicate>
OutputIterator	unique_copy (InputIterator first, InputIterator last, OutputIterator result, BinaryPredicate pred)
	unique implementation
template<class InputRange, class OutputIterator, class BinaryPredicate>
OutputIterator	unique_copy (InputRange &range, OutputIterator result, BinaryPredicate pred)
	unique implementation
template<class InputRange, class OutputIterator, class BinaryPredicate>
OutputIterator	unique_copy (const InputRange &range, OutputIterator result, BinaryPredicate pred)
	unique implementation
template<class T>
void	sort_unique (T &c)
	Sorts the sequence container c and erases all but one matching element.
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)
bool	operator== (const any_regular_t &x, const any_regular_t &y)
void	swap (any_regular_t &x, any_regular_t &y)
void	print (const any_regular_t &x)
template<typename T>
void	push_back (array_t &v, T x)
void	push_back (array_t &v, any_regular_t x)
template<typename T>
bool	operator== (const circular_queue< T > &x, const circular_queue< T > &y)
template<typename T>
void	swap (circular_queue< T > &, circular_queue< T > &)
double	round_half_up (double x)
float	round_half_up (float x)
long	lround_half_up (double x)
long	lround_half_up (float x)
template<typename R, typename A>
R	nearest_cast (const A &x)
template<typename lht, typename rht>
lht	explicit_cast (const rht &rhs)
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<typename T>
T &	remove_const (const T &x)
template<typename T>
bool	get_value (const dictionary_t &dict, name_t key, T &value)
bool	get_value (const dictionary_t &dict, name_t key, any_regular_t &value)
const any_regular_t &	get_value (const dictionary_t &dict, name_t key)
template<typename R>
R	get_dictionary_entry (adobe::dictionary_t const &dict, adobe::name_t const &key)
	dictionary_arg_stream requires specializations of get_dictionary_entry for the dictionary. For example, the adobe::dictionary_t specializations.
template<typename R>
bool	get_dictionary_entry (adobe::dictionary_t const &dict, adobe::name_t const &key, R &r)
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<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)
	call the function/callable-object f with args pulled from dictionary dict via keys from 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<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 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 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 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 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 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 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 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 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 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 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 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 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)
auto	adobe_enable_bitmask_enum (...) -> std::false_type
auto	adobe_enable_arithmetic_enum (...) -> std::false_type
void	set_margin (layout_attributes_t &container, int x)
eve_callback_suite_t	bind_layout (const bind_layout_proc_t &proc, sheet_t &layout_sheet, virtual_machine_t &evaluator)
void	apply_layout_parameters (layout_attributes_t &data, const dictionary_t &parameters)
adobe::any_regular_t	layout_variables (adobe::sheet_t &layout_sheet, adobe::name_t name)
line_position_t	parse (std::istream &in, const line_position_t &, const eve_callback_suite_t::position_t &, const eve_callback_suite_t &)
void	terminate (const char *)
void	terminate (const std::string &)
std::ostream &	operator<< (std::ostream &s, const extents_t &x)
std::ostream &	operator<< (std::ostream &s, const extents_t::slice_t &x)
template<std::size_t Bits, typename Iterator, typename Predicate>
fnvtype< Bits >	fnv1a (Iterator first, Predicate p)
template<std::size_t Bits, typename Iterator>
fnvtype< Bits >	fnv1a (Iterator first, Iterator last)
template<std::size_t Bits, typename Container>
fnvtype< Bits >	fnv1a (Container c)
template<typename I>
void	pivot (I &i)
template<typename I>
I	pivot_of (I i)
template<typename I>
I	leading_of (I i)
template<typename I>
I	trailing_of (I i)
template<typename I>
I	find_parent (I i)
template<typename I>
bool	has_children (const I &i)
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<typename T>
bool	operator== (const forest< T > &x, const forest< T > &y)
template<typename T>
bool	operator!= (const forest< T > &x, const forest< T > &y)
template<typename I>
child_iterator< I >	child_begin (const I &x)
template<typename I>
child_iterator< I >	child_end (const I &x)
template<typename I>
auto	child_range (const I &x) -> boost::iterator_range< child_iterator< I > >
const char *	current_exception_what ()
template<typename F>
bool	operator== (const function< F > &x, null_ptr_t)
template<typename F>
bool	operator== (null_ptr_t, const function< F > &x)
template<typename F>
bool	operator!= (const function< F > &x, null_ptr_t)
template<typename F>
bool	operator!= (null_ptr_t, const function< F > &x)
template<typename F, typename G>
unary_compose< F, G >	compose (F f, G g)
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<class T, typename R>
mem_data_t< T, R >	mem_data (R T::*member)
template<typename F>
auto	f_transpose (F f) -> transpose< F >
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<class F, class... Args>
auto	async (F &&f, Args &&... args) -> std::future< typename adobe::invoke_result_t< F, Args... > >
template<class Duration, class F, class... Args>
auto	async (const std::chrono::time_point< std::chrono::steady_clock, Duration > &when, F &&f, Args &&... args) -> std::future< adobe::invoke_result_t< F, Args... > >
std::ostream &	operator<< (std::ostream &, const line_position_t &)
std::ostream &	operator<< (std::ostream &, const stream_error_t &)
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 I>
std::pair< I, std::string >	get_line (I first, I last)
std::string	format_stream_error (std::istream &, const stream_error_t &)
std::string	format_stream_error (const stream_error_t &)
template<typename R>
boost::iterator_range< segmented_iterator< typename boost::range_iterator< R >::type > >	make_segmented_range (R &r)
template<typename R>
segmented_iterator< typename boost::range_iterator< R >::type >	make_segmented_iterator (R &r)
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 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 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 I>
boost::difference_type< I >::type	distance (I &range)
adobe::any_regular_t	json_parse (const char *data)
	A utility routine that takes in raw JSON data and produces a representation of that data using the common ASL data structures.
template<typename O>
O	json_generate (const adobe::any_regular_t &x, O out)
	A utility routine that takes in an any_regular_t and produces from it a well-formed representation of the structure in JSON.
int	top (const place_data_t &place_data)
int	left (const place_data_t &place_data)
int &	top (place_data_t &place_data)
int &	left (place_data_t &place_data)
int	height (const place_data_t &place_data)
int	width (const place_data_t &place_data)
int &	height (place_data_t &place_data)
int &	width (place_data_t &place_data)
int	bottom (const place_data_t &place_data)
int	right (const place_data_t &place_data)
void	localization_register (const localization_lookup_proc_t &proc)
std::string	localization_invoke (const std::string &source)
bool	localization_ready ()
template<typename T>
void	destroy (T *p)
template<class T, class... Args>
T *	construct_at (T *p, Args &&... args)
template<typename T, typename U>
constexpr auto	construct (T *p, U &&x)
template<typename T>
constexpr auto	construct (T *p)
template<typename F>
void	destroy (F f, F l)
template<typename I, typename F>
F	uninitialized_move (I f, I l, F r)
	Similar to std::uninitialized_copy but with move semantics.
template<typename I1, typename I2, typename N>
std::pair< I1, I2 >	mismatch_n (I1 first1, I2 first2, N n)
template<typename I1, typename I2>
std::pair< I1, I2 >	mismatch (I1 first1, I1 last1, I2 first2, I2 last2)
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<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 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 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<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 T>
void	measure (T &t, extents_t &result)
template<class T>
void	place (T &t, const place_data_t &place_data)
template<class T>
void	measure_vertical (T &t, extents_t &calculated_horizontal, const place_data_t &placed_horizontal)
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, 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 T>
bool	operator!= (const poly< T > &x, const poly< T > &y)
	inequality comparison
template<class T>
std::enable_if< has_ostream_insertion< T >::value >::type	ostream_insertion (std::ostream &s, const T &x)
template<class T>
std::enable_if<!has_ostream_insertion< T >::value >::type	ostream_insertion (std::ostream &, const T &)
template<>
void	ostream_insertion< bool > (std::ostream &s, const bool &x)
template<>
void	ostream_insertion< double > (std::ostream &s, const double &x)
std::ostream &	operator<< (std::ostream &s, const serializable_t &x)
std::string	make_string (const char *a, const char *b)
std::string	make_string (const char *a, const char *b, const char *c)
template<typename O>
O	to_string (double x, O out, bool precise=false)
	Convert double precision floating point numbers to ascii representation.
std::string	to_string (double x)
	Convert double precision floating point numbers to ascii representation.
bool	operator!= (const cancellation_token &x, const cancellation_token &y)
bool	operator!= (const cancellation_token_source &x, const cancellation_token_source &y)
void	cancel_current_task ()
template<typename T>
void	check_container (const T &c)
template<typename T, typename Op>
void	check_transitive (const T &x, const T &y, const T &z, Op op)
template<typename T, typename Op>
void	check_irreflexive (const T &x, Op op)
template<typename T, typename Op>
void	check_antisymmetric (const T &x, const T &y, 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>
T	arbitrary_regular_value ()
template<typename T>
void	check_regular (const T &x)
	BOOST_TEST_CASE_TEMPLATE_FUNCTION (check_regulars, T)
template<typename T>
void	check_traversable (const T &c)
thread_id_t	thread_id ()
bool	operator== (const timer_t &x, const timer_t &y)
bool	operator< (const timer_t &x, const timer_t &y)
template<typename T, typename I, typename O>
O	copy_utf (I f, I l, O o)
template<typename T, typename R, typename O>
O	copy_utf (const R &r, O o)
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 &)
const char *	type_name (const std::type_info &type)
	Returns a simple name for the core types used by the virtual machine.
template<class T>
auto	cast (adobe::any_regular_t &x) -> decltype(x.cast< T >())
	Does a runtime cast on an any_regular_t with better error reporting.
template<class T>
auto	cast (const adobe::any_regular_t &x) -> decltype(x.cast< T >())
	Does a runtime cast on an any_regular_t with better error reporting.
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_strip (const token_range_t &, const token_range_t &, const attribute_set_t &, const token_range_t &value)
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)
template<typename Result, typename InputIterator>
InputIterator	xatoi (InputIterator first, InputIterator last, Result &result)
template<typename Result, typename InputIterator>
InputIterator	datoi (InputIterator first, InputIterator last, Result &result)
void	xstring_clear_glossary ()
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<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)
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)
bool	operator== (const zuid_t &a, const zuid_t &b)
bool	operator< (const zuid_t &a, const zuid_t &b)
void	pivot (I &iter)
I	pivot_of (I iter)
C	trailing_of (C cursor)
C	leading_of (C cursor)
bool	has_children (const C &cursor)
ForestTraveler	find_parent (ForestTraveler traveler)
child_iterator< BeadIterator >	child_begin (const BeadIterator &iter)
child_iterator< BeadIterator >	child_end (const BeadIterator &iter)
	uuid_t
adobe::my_return_t	related_non_member_function ()
	A one-line synopsis of this member function.
bool	empty (const any_regular_t &x)
bool	operator== (const circular_queue &x, const circular_queue &y)
bool	swap (circular_queue &x, circular_queue &y)
template<typename R, typename P>
auto	filter_fullorder_range (R &x, P p) -> boost::iterator_range< filter_fullorder_iterator< typename boost::range_iterator< R >::type, P > >
template<typename R, typename P>
auto	filter_fullorder_range (const R &x, P p) -> boost::iterator_range< filter_fullorder_iterator< typename boost::range_const_iterator< R >::type, P > >
template<typename R>
auto	reverse_fullorder_range (R &x) -> boost::iterator_range< reverse_fullorder_iterator< typename boost::range_iterator< R >::type > >
template<typename R>
boost::iterator_range< reverse_fullorder_iterator< typename boost::range_const_iterator< R >::type > >	reverse_fullorder_range (const R &x)
template<typename R>
boost::iterator_range< depth_fullorder_iterator< typename boost::range_iterator< R >::type > >	depth_range (R &x)
template<typename R>
boost::iterator_range< depth_fullorder_iterator< typename boost::range_const_iterator< R >::type > >	depth_range (const R &x)
template<typename R>
boost::iterator_range< edge_iterator< typename boost::range_iterator< R >::type, forest_trailing_edge > >	postorder_range (R &x)
template<typename R>
boost::iterator_range< edge_iterator< typename boost::range_const_iterator< R >::type, forest_trailing_edge > >	postorder_range (const R &x)
template<typename R>
boost::iterator_range< edge_iterator< typename boost::range_iterator< R >::type, forest_leading_edge > >	preorder_range (R &x)
template<typename R>
boost::iterator_range< edge_iterator< typename boost::range_const_iterator< R >::type, forest_leading_edge > >	preorder_range (const R &x)
template<typename SourceForestIterType, typename DestForestType, typename UnaryFunction>
void	transform_forest (SourceForestIterType first, SourceForestIterType last, DestForestType &destForest, typename DestForestType::iterator destIter, UnaryFunction transformFunc)
template<typename SourceForestIterType, typename DestForestType, typename UnaryFunction>
void	transform_forest (SourceForestIterType first, SourceForestIterType last, DestForestType &destForest, UnaryFunction transformFunc)
template<typename SourceForestType, typename DestForestType, typename UnaryFunction>
void	transform_forest (SourceForestType sourceForest, DestForestType &destForest, typename DestForestType::iterator destIter, UnaryFunction transformFunc)
template<typename SourceForestType, typename DestForestType, typename UnaryFunction>
void	transform_forest (SourceForestType sourceForest, DestForestType &destForest, UnaryFunction transformFunc)
md5_t::digest_t	md5 (void *input_block, std::size_t input_length)
void	swap (adobe::table_index &x, adobe::table_index &y)
bool	operator== (const attribute_set_t &x, const attribute_set_t &y)
std::ostream &	operator<< (std::ostream &s, const attribute_set_t &attribute_set)
template<typename O>
xml_parser_t< O >	make_xml_parser (uchar_ptr_t first, uchar_ptr_t last, const line_position_t &position, typename xml_parser_t< O >::preorder_predicate_t predicate, typename xml_parser_t< O >::callback_proc_t callback, O output)
	Create an object that will parse the indicated content range using the preorder and content functions indicated.

Variables
template<typename T>
const function< R()>::vtable_type	function< R()>::model< T >::vtable_s
const new_delete_t	local_new_delete_g

Detailed Description

This library implements portions of the Microsoft PPL task cancelation API:

cancellation_token_source http://msdn.microsoft.com/en-us/library/hh749985.aspx

• with the exception of create_linked_source() cancellation_token http://msdn.microsoft.com/en-us/library/hh749975.aspx cancellation_token_registration http://msdn.microsoft.com/en-us/library/hh750057.aspx task_canceled http://msdn.microsoft.com/en-us/library/hh750110.aspx cancel_current_task http://msdn.microsoft.com/en-us/library/hh749945.aspx

For detailed documentation on using this library see: http://msdn.microsoft.com/en-us/library/dd984117.aspx

Typedef Documentation

array_t

typedef std::vector<any_regular_t> array_t

Definition at line 23 of file array_fwd.hpp.

promote_t

template<class T>

using promote_t

Definition at line 32 of file conversion.hpp.

copy_on_write

template<class T>

using copy_on_write

An alias to stlab/copy_on_write for compatibility.

Definition at line 26 of file copy_on_write.hpp.

pair_long_t

typedef std::pair<int, int> pair_long_t

Definition at line 43 of file extents.hpp.

point_2d_t

typedef point_2d<int> point_2d_t

Definition at line 44 of file extents.hpp.

guide_set_t

typedef std::vector<int> guide_set_t

Definition at line 45 of file extents.hpp.

null_ptr_t

typedef void_* null_ptr_t

Definition at line 49 of file function.hpp.

poly_copyable_t

typedef poly<copyable> poly_copyable_t

Definition at line 87 of file poly_copyable.hpp.

poly_regular_t

typedef poly<regular> poly_regular_t

Definition at line 108 of file poly_regular.hpp.

has_ostream_insertion

template<class T>

using has_ostream_insertion

Definition at line 55 of file serializable.hpp.

cancellation_token_registration

typedef std::function<void()>* cancellation_token_registration

Definition at line 66 of file task.hpp.

invoke_result_t

template<class F, class... Args>

using invoke_result_t

Definition at line 22 of file type_traits.hpp.

implementation_xml_element_proc_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)

Definition at line 406 of file xml_parser.hpp.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
forest_trailing_edge
forest_leading_edge

Definition at line 39 of file forest.hpp.

json_type

enum class json_type

strong

Enumerator
object
array
string
number
boolean
null

Definition at line 468 of file json.hpp.

Function Documentation

bind_to_sheet()

adam_callback_suite_t bind_to_sheet	(	sheet_t &	,
		external_model_t &	)

append()

template<class T, class R>

auto append	(	T &	c,
		const R &	r )

Insert the elements of input_range r at the end of the sequence container c, returning the position corresponding to the incoming end of c.

Definition at line 22 of file append.hpp.

lower_bound_n() [1/3]

template<typename I, typename N, typename T>

I lower_bound_n	(	I	f,
		N	n,
		const T &	x )

Definition at line 73 of file lower_bound.hpp.

lower_bound_n() [2/3]

template<typename I, typename N, typename T, typename C>

I lower_bound_n	(	I	f,
		N	n,
		const T &	x,
		C	c )

Definition at line 84 of file lower_bound.hpp.

lower_bound_n() [3/3]

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 )

Definition at line 97 of file lower_bound.hpp.

sort_unique()

template<class T>

void sort_unique

(

T &

c

)

Definition at line 119 of file unique.hpp.

upper_bound_n() [1/3]

template<typename I, typename N, typename T>

I upper_bound_n	(	I	f,
		N	n,
		const T &	x )

Definition at line 77 of file upper_bound.hpp.

upper_bound_n() [2/3]

template<typename I, typename N, typename T, typename C>

I upper_bound_n	(	I	f,
		N	n,
		const T &	x,
		C	c )

Definition at line 88 of file upper_bound.hpp.

upper_bound_n() [3/3]

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 )

Definition at line 101 of file upper_bound.hpp.

print()

void print

(

const any_regular_t &

x

)

push_back() [1/2]

template<typename T>

void push_back	(	array_t &	v,
		T	x )

Definition at line 28 of file array.hpp.

push_back() [2/2]

void push_back	(	array_t &	v,
		any_regular_t	x )

Definition at line 32 of file array.hpp.

operator==() [1/9]

template<typename T>

bool operator==	(	const circular_queue< T > &	x,
		const circular_queue< T > &	y )

Definition at line 424 of file circular_queue.hpp.

swap() [1/4]

template<typename T>

void swap	(	circular_queue< T > &	,
		circular_queue< T > &	)

runtime_cast() [1/3]

template<typename R, typename T>

R runtime_cast

(

T &

x

)

Definition at line 49 of file conversion.hpp.

runtime_cast() [2/3]

template<typename R, typename T>

R runtime_cast

(

T *

x

)

Definition at line 54 of file conversion.hpp.

runtime_cast() [3/3]

template<typename R, typename T>

bool runtime_cast	(	const T &	x,
		R &	r )

Definition at line 59 of file conversion.hpp.

get_dictionary_entry()

template<typename R>

bool get_dictionary_entry	(	adobe::dictionary_t const &	dict,
		adobe::name_t const &	key,
		R &	r )

Definition at line 43 of file dictionary_arg_stream.hpp.

make_dictionary_arg_stream() [1/2]

template<typename Dictionary, typename InputRange>

dictionary_arg_stream< Dictionary, InputRange, void > make_dictionary_arg_stream	(	Dictionary &	dict,
		InputRange const &	key_range )

Definition at line 137 of file dictionary_arg_stream.hpp.

make_dictionary_arg_stream() [2/2]

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	)

Definition at line 143 of file dictionary_arg_stream.hpp.

call_with_dictionary() [1/7]

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 )

Definition at line 264 of file dictionary_arg_stream.hpp.

call_member_with_dictionary() [1/8]

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 )

Definition at line 275 of file dictionary_arg_stream.hpp.

call_member_with_dictionary() [2/8]

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 )

Definition at line 283 of file dictionary_arg_stream.hpp.

call_with_dictionary() [2/7]

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 )

Definition at line 293 of file dictionary_arg_stream.hpp.

call_member_with_dictionary() [3/8]

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 )

Definition at line 302 of file dictionary_arg_stream.hpp.

call_with_dictionary() [3/7]

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 )

Definition at line 310 of file dictionary_arg_stream.hpp.

call_member_with_dictionary() [4/8]

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 )

Definition at line 318 of file dictionary_arg_stream.hpp.

call_with_dictionary() [4/7]

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 )

Definition at line 328 of file dictionary_arg_stream.hpp.

call_member_with_dictionary() [5/8]

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 )

Definition at line 336 of file dictionary_arg_stream.hpp.

call_with_dictionary() [5/7]

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 )

Definition at line 345 of file dictionary_arg_stream.hpp.

call_member_with_dictionary() [6/8]

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 )

Definition at line 354 of file dictionary_arg_stream.hpp.

call_with_dictionary() [6/7]

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 )

Definition at line 363 of file dictionary_arg_stream.hpp.

call_member_with_dictionary() [7/8]

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 )

Definition at line 374 of file dictionary_arg_stream.hpp.

call_with_dictionary() [7/7]

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 )

Definition at line 383 of file dictionary_arg_stream.hpp.

call_member_with_dictionary() [8/8]

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 )

Definition at line 393 of file dictionary_arg_stream.hpp.

adobe_enable_bitmask_enum()

auto adobe_enable_bitmask_enum

(

...

)

-> std::false_type

adobe_enable_arithmetic_enum()

auto adobe_enable_arithmetic_enum

(

...

)

-> std::false_type

bind_layout()

eve_callback_suite_t bind_layout	(	const bind_layout_proc_t &	proc,
		sheet_t &	layout_sheet,
		virtual_machine_t &	evaluator )

apply_layout_parameters()

void apply_layout_parameters	(	layout_attributes_t &	data,
		const dictionary_t &	parameters )

layout_variables()

adobe::any_regular_t layout_variables	(	adobe::sheet_t &	layout_sheet,
		adobe::name_t	name )

terminate() [1/2]

void terminate

(

const char *

)

invoke std::terminate with the given message in what() for the current exception. The message can be retrieved in a terminate handler and is reported by the default terminate handler.

terminate() [2/2]

void terminate

(

const std::string &

)

operator<<() [1/6]

std::ostream & operator<<	(	std::ostream &	s,
		const extents_t &	x )

operator<<() [2/6]

std::ostream & operator<<	(	std::ostream &	s,
		const extents_t::slice_t &	x )

pivot() [1/2]

template<typename I>

void pivot ( I & i )

related

Definition at line 44 of file forest.hpp.

pivot_of() [1/2]

template<typename I>

I pivot_of ( I i )

related

Definition at line 49 of file forest.hpp.

leading_of() [1/2]

template<typename I>

I leading_of

(

I

i

)

Definition at line 57 of file forest.hpp.

trailing_of() [1/2]

template<typename I>

I trailing_of

(

I

i

)

Definition at line 63 of file forest.hpp.

find_parent() [1/2]

template<typename I>

I find_parent

(

I

i

)

Definition at line 71 of file forest.hpp.

has_children() [1/2]

template<typename I>

bool has_children

(

const I &

i

)

Definition at line 82 of file forest.hpp.

find_edge()

template<typename I>

I find_edge	(	I	x,
		std::size_t	edge )

Definition at line 112 of file forest.hpp.

find_edge_reverse()

template<typename I>

I find_edge_reverse	(	I	x,
		std::size_t	edge )

Definition at line 119 of file forest.hpp.

operator==() [2/9]

template<typename T>

bool operator==	(	const forest< T > &	x,
		const forest< T > &	y )

Definition at line 704 of file forest.hpp.

operator!=() [1/5]

template<typename T>

bool operator!=	(	const forest< T > &	x,
		const forest< T > &	y )

Definition at line 722 of file forest.hpp.

child_begin() [1/2]

template<typename I>

child_iterator< I > child_begin

(

const I &

x

)

Definition at line 924 of file forest.hpp.

child_end() [1/2]

template<typename I>

child_iterator< I > child_end

(

const I &

x

)

Definition at line 931 of file forest.hpp.

child_range()

template<typename I>

auto child_range

(

const I &

x

)

-> boost::iterator_range<child_iterator<I>>

Definition at line 969 of file forest.hpp.

current_exception_what()

const char * current_exception_what

(

)

Definition at line 34 of file function.hpp.

async() [1/2]

template<class F, class... Args>

auto async	(	F &&	f,
		Args &&...	args ) -> std::future<typename adobe::invoke_result_t<F, Args...>>

Definition at line 67 of file future.hpp.

async() [2/2]

template<class Duration, class F, class... Args>

auto async	(	const std::chrono::time_point< std::chrono::steady_clock, Duration > &	when,
		F &&	f,
		Args &&...	args ) -> std::future<adobe::invoke_result_t<F, Args...>>

Definition at line 84 of file future.hpp.

operator<<() [3/6]

std::ostream & operator<<	(	std::ostream &	,
		const line_position_t &	)

operator<<() [4/6]

std::ostream & operator<<	(	std::ostream &	,
		const stream_error_t &	)

is_line_end() [1/2]

template<typename I>

bool is_line_end	(	I &	first,
		I	last )

Definition at line 217 of file istream.hpp.

is_line_end() [2/2]

template<typename I>

std::size_t is_line_end	(	I &	first,
		I	last,
		char	c )

Definition at line 236 of file istream.hpp.

get_line()

template<typename I>

std::pair< I, std::string > get_line	(	I	first,
		I	last )

Definition at line 258 of file istream.hpp.

format_stream_error() [1/2]

std::string format_stream_error	(	std::istream &	,
		const stream_error_t &	)

format_stream_error() [2/2]

std::string format_stream_error

(

const stream_error_t &

)

destroy() [1/2]

template<typename T>

void destroy

(

T *

p

)

Definition at line 341 of file memory.hpp.

construct_at()

template<class T, class... Args>

T * construct_at	(	T *	p,
		Args &&...	args )

Definition at line 350 of file memory.hpp.

construct() [1/2]

template<typename T, typename U>

auto construct ( T * p, U && x )

constexpr

Definition at line 355 of file memory.hpp.

construct() [2/2]

template<typename T>

auto construct ( T * p )

constexpr

Definition at line 360 of file memory.hpp.

destroy() [2/2]

template<typename F>

void destroy	(	F	f,
		F	l )

Definition at line 365 of file memory.hpp.

uninitialized_move()

template<typename I, typename F>

F uninitialized_move	(	I	f,
		I	l,
		F	r )

Definition at line 380 of file memory.hpp.

mismatch_n()

template<typename I1, typename I2, typename N>

std::pair< I1, I2 > mismatch_n	(	I1	first1,
		I2	first2,
		N	n )

Definition at line 46 of file mismatch.hpp.

mismatch()

template<typename I1, typename I2>

std::pair< I1, I2 > mismatch	(	I1	first1,
		I1	last1,
		I2	first2,
		I2	last2 )

Definition at line 59 of file mismatch.hpp.

ostream_insertion() [1/2]

template<class T>

std::enable_if< has_ostream_insertion< T >::value >::type ostream_insertion	(	std::ostream &	s,
		const T &	x )

Definition at line 61 of file serializable.hpp.

ostream_insertion() [2/2]

template<class T>

std::enable_if<!has_ostream_insertion< T >::value >::type ostream_insertion	(	std::ostream &	,
		const T &	)

Definition at line 67 of file serializable.hpp.

ostream_insertion< bool >()

template<>

void ostream_insertion< bool >	(	std::ostream &	s,
		const bool &	x )

Definition at line 80 of file serializable.hpp.

ostream_insertion< double >()

template<>

void ostream_insertion< double >	(	std::ostream &	s,
		const double &	x )

Definition at line 85 of file serializable.hpp.

operator<<() [5/6]

std::ostream & operator<<	(	std::ostream &	s,
		const serializable_t &	x )

Definition at line 168 of file serializable.hpp.

make_string() [1/2]

std::string make_string	(	const char *	a,
		const char *	b )

Definition at line 31 of file string.hpp.

make_string() [2/2]

std::string make_string	(	const char *	a,
		const char *	b,
		const char *	c )

Definition at line 41 of file string.hpp.

operator!=() [2/5]

bool operator!=	(	const cancellation_token &	x,
		const cancellation_token &	y )

Definition at line 182 of file task.hpp.

operator!=() [3/5]

bool operator!=	(	const cancellation_token_source &	x,
		const cancellation_token_source &	y )

Definition at line 205 of file task.hpp.

cancel_current_task()

void cancel_current_task

(

)

Definition at line 223 of file task.hpp.

operator==() [3/9]

bool operator==	(	const timer_t &	x,
		const timer_t &	y )

Definition at line 276 of file timer.hpp.

operator<() [1/2]

bool operator<	(	const timer_t &	x,
		const timer_t &	y )

Definition at line 280 of file timer.hpp.

type_name()

const char * type_name

(

const std::type_info &

type

)

cast() [1/2]

template<class T>

auto cast

(

adobe::any_regular_t &

x

)

-> decltype(x.cast<T>())

Definition at line 42 of file virtual_machine.hpp.

cast() [2/2]

template<class T>

auto cast

(

const adobe::any_regular_t &

x

)

-> decltype(x.cast<T>())

Definition at line 53 of file virtual_machine.hpp.

xml_element_echo()

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 &	)

Definition at line 588 of file xml_parser.hpp.

xml_element_strip()

token_range_t xml_element_strip	(	const token_range_t &	,
		const token_range_t &	,
		const attribute_set_t &	,
		const token_range_t &	value )

Definition at line 597 of file xml_parser.hpp.

xml_element_linefeed()

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 )

Definition at line 606 of file xml_parser.hpp.

xatoi()

template<typename Result, typename InputIterator>

InputIterator xatoi	(	InputIterator	first,
		InputIterator	last,
		Result &	result )

hexadecimal atoi

Iterator-based atoi, but for hexadecimal number strings.

Definition at line 1138 of file xml_parser.hpp.

datoi()

template<typename Result, typename InputIterator>

InputIterator datoi	(	InputIterator	first,
		InputIterator	last,
		Result &	result )

decimal atoi

Iterator-based atoi

Definition at line 1167 of file xml_parser.hpp.

operator==() [4/9]

bool operator==	(	const zuid_t &	a,
		const zuid_t &	b )

operator<() [2/2]

bool operator<	(	const zuid_t &	a,
		const zuid_t &	b )