stlab.adobe.com Adobe Systems Incorporated
adobe Namespace Reference

Namespaces

 arg_stream
 
 detail
 
 dictionary_arg_stream_detail
 
 fn
 
 unsafe
 
 version_0
 
 version_1
 

Classes

class  adam_callback_suite_t
 
struct  aggregate_pair
 
struct  aligned_storage
 
struct  always_true
 
struct  any_bidirectional_iterator_instance
 
struct  any_bidirectional_iterator_interface
 
class  any_iterator
 
struct  any_random_access_iterator_instance
 
struct  any_random_access_iterator_interface
 
class  asl_cel_format
 
struct  assign
 
class  attribute_set_t
 
class  auto_ptr
 
class  auto_resource
 
class  back_move_iterator
 
class  bad_cast
 
class  basic_bounded_width
 
class  basic_format
 
class  basic_omanipulator
 
class  basic_omanipulator2
 
class  begin_atom
 
class  begin_bag
 
struct  bidirectional_iter
 
struct  binary_compose
 
class  bitwise_and
 
class  bitwise_or
 
class  bitwise_xor
 
class  child_adaptor
 
class  child_iterator
 
class  circular_queue
 
class  closed_hash_map
 
class  closed_hash_set
 
class  compare_members_t
 
class  const_once_name_t
 
struct  constructor
 
struct  copy_sink
 
struct  copyable
 
class  counter_t
 
class  counting_output_iterator
 
class  dancing_links
 
class  dancing_links_t
 
struct  dec
 
struct  delete_array
 
struct  delete_ptr
 
struct  delete_ptr_trait
 
struct  delete_ptr_trait< T * >
 
struct  delete_ptr_trait< T(*)[]>
 
class  depth_fullorder_cursor
 
class  depth_fullorder_iterator
 
struct  dictionary_arg_stream
 
struct  dictionary_arg_stream< Dictionary, InputRange, std::nothrow_t >
 
struct  dictionary_arg_stream_base
 
class  edge_iterator
 
struct  element
 
struct  element< 0, pair< T1, T2 > >
 
struct  element< 0, std::pair< T1, T2 > >
 
struct  element< 1, pair< T1, T2 > >
 
struct  element< 1, std::pair< T1, T2 > >
 
struct  empty_base
 
struct  empty_ptr
 
struct  empty_ptr< T * >
 
struct  empty_ptr< T(*)[]>
 
struct  equal_to
 
struct  equivalent
 
struct  eve_callback_suite_t
 
class  eve_t
 
class  extents_slices_t
 
class  extents_t
 
class  external_model_t
 
class  filter_fullorder_cursor
 
class  filter_fullorder_iterator
 
class  forest
 
class  format_base
 
class  format_element_t
 
class  generator_t
 
struct  get_element
 
struct  get_element< 0, pair< T1, T2 > >
 
struct  get_element< 0, std::pair< T1, T2 > >
 
struct  get_element< 1, pair< T1, T2 > >
 
struct  get_element< 1, std::pair< T1, T2 > >
 
struct  greater
 
struct  greater_equal
 
struct  has_type_type
 
class  hash_index
 
struct  identity
 
struct  identity_element
 
struct  identity_element< std::multiplies< T > >
 
struct  identity_element< std::plus< T > >
 
struct  inc
 
class  indents
 
class  index_iterator
 
struct  indirect
 
class  indirect_t
 
struct  is_convertible
 
struct  is_member
 
struct  is_movable
 
struct  is_movable< copy_on_write< T, A > >
 
struct  is_range
 
struct  iter
 
class  javascript_format
 
class  layout_attributes_alignment_t
 
struct  layout_attributes_placement_t
 
class  layout_attributes_t
 
struct  less
 
struct  less_equal
 
class  lex_stream_t
 
struct  lex_token_t
 
class  line_position_t
 
struct  logical_and
 
struct  logical_not
 
struct  logical_or
 
struct  logical_xor
 
class  manipulator_base
 
class  marshaled_exception
 
class  md5_t
 
class  mem_data_t
 
struct  mem_data_t< const T, R >
 
struct  move_from
 
struct  move_sink
 
class  my_class_t
 
class  name_t
 
class  nearest_cast_fn
 
struct  nearest_cast_fn< A, double >
 
struct  nearest_cast_fn< A, float >
 
struct  not_equal_to
 
struct  null_output_iterator_t
 
struct  optimized_storage_type
 
struct  pair
 
class  pdf_format
 
class  place_data_t
 
struct  placeable
 
struct  placeable_twopass
 
struct  PlaceableConcept
 
struct  PlaceableConcept< T * >
 
struct  PlaceableTwoPassConcept
 
struct  PlaceableTwoPassConcept< T * >
 
struct  plus_asymmetric
 
struct  point_2d
 
struct  pointer_to
 
class  poly
 
struct  poly_base
 
struct  poly_copyable_instance
 
struct  poly_copyable_interface
 
struct  poly_iterator_instance
 
struct  poly_iterator_interface
 
struct  poly_placeable_instance
 
struct  poly_placeable_interface
 
struct  poly_placeable_twopass_instance
 
struct  poly_placeable_twopass_interface
 
struct  poly_regular_instance
 
struct  poly_regular_interface
 
class  promote
 
struct  promote< aggregate_name_t >
 
struct  promote< const char * >
 
struct  promote< float >
 
struct  promote< int >
 
struct  promote< long >
 
struct  promote< short >
 
struct  promote< static_name_t >
 
struct  promote< std::string >
 
struct  promote< unsigned int >
 
struct  promote< unsigned long >
 
struct  promote< unsigned short >
 
struct  ptr_traits
 
struct  ptr_traits< auto_ptr< T, Traits > >
 
struct  ptr_traits< auto_resource< T, Traits > >
 
struct  ptr_traits< std::auto_ptr< T > >
 
struct  ptr_traits< T * >
 
struct  ptr_traits< T(*)[]>
 
struct  random_access_iter
 
struct  regular
 
struct  RegularConcept
 
class  reverse_fullorder_cursor
 
class  reverse_fullorder_iterator
 
struct  runtime_cast_t
 
struct  runtime_cast_t< R, any_regular_t * >
 
struct  runtime_cast_t< R, any_regular_t >
 
struct  runtime_cast_t< R, auto_ptr< T, Traits > >
 
struct  runtime_cast_t< R, auto_resource< T, Traits > >
 
struct  runtime_cast_t< R, const any_regular_t * >
 
struct  runtime_cast_t< R, const any_regular_t >
 
struct  runtime_cast_t< R, std::auto_ptr< T > >
 
class  segmented_iterator
 
struct  select
 
class  selection_t
 
class  sequence_t
 
struct  set_monitor_t
 
class  sha1_t
 
class  sha224_t
 
class  sha256_t
 
class  sha384_t
 
class  sha512_t
 
class  sheet_t
 
struct  short_name
 
class  static_name_t
 
class  static_table
 
class  static_table_traits
 
class  step_iterator_adaptor
 
struct  str_less_t
 
class  stream_error_t
 
class  string16_t
 
class  string_t
 
class  table_index
 
class  timer_t
 
struct  transposer
 
struct  type_or_default
 
struct  unary_compose
 
struct  uuid_t
 
class  value_iterator
 
class  virtual_machine_t
 
class  xml_format
 
class  xml_parser_t
 
class  xstring_context_t
 
class  zuid_t
 

Typedefs

typedef version_1::any_regular_t any_regular_t
 
typedef version_1::vector< any_regular_tarray_t
 
typedef boost::function< eve_callback_suite_t::position_t(const eve_callback_suite_t::position_t &parent, name_t name, dictionary_t arguments)> bind_layout_proc_t
 
typedef basic_bounded_width< char, std::char_traits< char > > bounded_width
 
typedef version_1::closed_hash_map closed_hash_map
 
typedef version_1::closed_hash_set closed_hash_set
 
typedef version1::closed_hash_map< name_t, any_regular_tdictionary_t
 
typedef std::vector< int > guide_set_t
 
typedef token_range_t() implementation_xml_element_proc_t(const token_range_t &entire_element_range, const token_range_t &name, const attribute_set_t &attribute_set, const token_range_t &value)
 
typedef long intptr_t
 
typedef bool() keyword_extension_lookup_proc_signature_t(const name_t &)
 
typedef boost::function< keyword_extension_lookup_proc_signature_tkeyword_extension_lookup_proc_t
 
typedef boost::function< std::string(const std::string &)> localization_lookup_proc_t
 
typedef void_ * null_ptr_t
 
typedef bool once_flag
 
typedef std::pair< int, int > pair_long_t
 
typedef point_2d< int > point_2d_t
 
typedef poly< placeablepoly_placeable_t
 
typedef poly< placeable_twopasspoly_placeable_twopass_t
 
typedef pair< name_t, any_regular_tstream_lex_token_t
 
typedef const struct thread_id_opaque_t * thread_id_t
 
typedef std::pair< uchar_ptr_t, uchar_ptr_ttoken_range_t
 
typedef const unsigned char * uchar_ptr_t
 
typedef unsigned long uintptr_t
 
typedef basic_bounded_width< wchar_t, std::char_traits< wchar_t > > wbounded_width
 
typedef boost::function< implementation_xml_element_proc_txml_element_proc_t
 

Enumerations

enum  { forest_trailing_edge, forest_leading_edge }
 
enum  modifiers_t {
  modifiers_none_s, modifiers_left_shift_s, modifiers_right_shift_s, modifiers_left_option_s,
  modifiers_right_option_s, modifiers_left_control_s, modifiers_right_control_s, modifiers_caps_lock_s,
  modifiers_any_command_s, modifiers_any_shift_s, modifiers_any_option_s, modifiers_any_control_s,
  modifiers_all_s
}
 
enum  theme_t {
  theme_none_s, theme_large_s, theme_normal_s, theme_small_s,
  theme_mini_s, theme_adornment_label_s, theme_adornment_number_s, theme_adornment_mono_s,
  theme_mask_s, theme_adornment_mask_s, theme_default_s
}
 

Functions

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

Variables

aggregate_name_t add_k
 
static const aggregate_name_t alt_name_g
 
aggregate_name_t and_k
 
aggregate_name_t array_k
 
aggregate_name_t assign_k
 
aggregate_name_t at_k
 
static const aggregate_name_t atom_name_g
 
static const aggregate_name_t bag_name_g
 
aggregate_name_t close_brace_k
 
aggregate_name_t close_bracket_k
 
aggregate_name_t close_parenthesis_k
 
aggregate_name_t colon_k
 
aggregate_name_t comma_k
 
aggregate_name_t dictionary_k
 
aggregate_name_t divide_k
 
aggregate_name_t dot_k
 
aggregate_name_t empty_k
 
aggregate_name_t eof_k
 
aggregate_name_t equal_k
 
aggregate_name_t false_k
 
aggregate_name_t function_k
 
aggregate_name_t greater_equal_k
 
aggregate_name_t greater_k
 
aggregate_name_t identifier_k
 
aggregate_name_t ifelse_k
 
aggregate_name_t index_k
 
aggregate_name_t is_k
 
aggregate_name_t keyword_k
 
aggregate_name_t lead_comment_k
 
aggregate_name_t less_equal_k
 
aggregate_name_t less_k
 
aggregate_name_t modulus_k
 
aggregate_name_t multiply_k
 
aggregate_name_t not_equal_k
 
aggregate_name_t not_k
 
aggregate_name_t number_k
 
aggregate_name_t open_brace_k
 
aggregate_name_t open_bracket_k
 
aggregate_name_t open_parenthesis_k
 
aggregate_name_t or_k
 
aggregate_name_t question_k
 
aggregate_name_t semicolon_k
 
static const aggregate_name_t seq_name_g
 
aggregate_name_t string_k
 
aggregate_name_t subtract_k
 
aggregate_name_t to_k
 
aggregate_name_t trail_comment_k
 
aggregate_name_t true_k
 
aggregate_name_t unary_negate_k
 
aggregate_name_t variable_k
 

Compatibility

Compatibility features for C99/TR1 <cmath>.

typedef Float double_t
 
typedef Float float_t
 
double round (double x)
 
float round (float x)
 
long lround (double x)
 
long lround (float x)
 
double trunc (double x)
 
float trunc (float x)
 

Typedef Documentation

◆ closed_hash_map

◆ guide_set_t

typedef std::vector<int> guide_set_t

Definition at line 53 of file extents.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 430 of file xml_parser.hpp.

◆ keyword_extension_lookup_proc_signature_t

typedef bool() keyword_extension_lookup_proc_signature_t(const name_t &)

Definition at line 34 of file lex_stream_fwd.hpp.

◆ keyword_extension_lookup_proc_t

◆ null_ptr_t

typedef void_* null_ptr_t

Definition at line 49 of file function.hpp.

◆ pair_long_t

typedef std::pair<int, int> pair_long_t

Definition at line 51 of file extents.hpp.

◆ point_2d_t

typedef point_2d<int> point_2d_t

Definition at line 52 of file extents.hpp.

◆ stream_lex_token_t

Definition at line 275 of file lex_shared_fwd.hpp.

◆ uchar_ptr_t

typedef const unsigned char* uchar_ptr_t

Definition at line 42 of file lex_shared_fwd.hpp.

Enumeration Type Documentation

◆ anonymous enum

anonymous enum
Enumerator
forest_trailing_edge 
forest_leading_edge 

Definition at line 39 of file forest.hpp.

Function Documentation

◆ apply_layout_parameters()

void adobe::apply_layout_parameters ( layout_attributes_t data,
const dictionary_t parameters 
)

◆ begin_alternate()

format_base::stream_type& adobe::begin_alternate ( format_base::stream_type os)

◆ begin_format()

format_base::stream_type& adobe::begin_format ( format_base::stream_type os)

◆ begin_sequence()

format_base::stream_type& adobe::begin_sequence ( format_base::stream_type os)

◆ bind_layout()

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

◆ bind_to_sheet()

adam_callback_suite_t adobe::bind_to_sheet ( sheet_t ,
external_model_t  
)

◆ BOOST_STATIC_ASSERT()

adobe::BOOST_STATIC_ASSERT ( sizeof(closed_hash_set< int >)  = =sizeof(void *))

◆ call_member_with_dictionary() [1/8]

arg_stream::result_type<F>::type adobe::call_member_with_dictionary ( T *  that,
f,
Dictionary const &  dict,
SingleArg const &  key_or_key_range 
)

Definition at line 321 of file dictionary_arg_stream.hpp.

◆ call_member_with_dictionary() [2/8]

arg_stream::result_type<F>::type adobe::call_member_with_dictionary ( T *  that,
f,
std::nothrow_t  ,
Dictionary const &  dict,
SingleArg const &  key_or_key_range 
)

Definition at line 328 of file dictionary_arg_stream.hpp.

◆ call_member_with_dictionary() [3/8]

arg_stream::result_type<F>::type adobe::call_member_with_dictionary ( X &  x,
f,
Dictionary const &  dict,
T1 const &  key1,
T2 const &  key2 
)

Definition at line 347 of file dictionary_arg_stream.hpp.

◆ call_member_with_dictionary() [4/8]

arg_stream::result_type<F>::type adobe::call_member_with_dictionary ( x,
f,
std::nothrow_t  ,
Dictionary const &  dict,
T1 const &  key1,
T2 const &  key2 
)

Definition at line 367 of file dictionary_arg_stream.hpp.

◆ call_member_with_dictionary() [5/8]

arg_stream::result_type<F>::type adobe::call_member_with_dictionary ( X &  x,
f,
Dictionary const &  dict,
T1 const &  key1,
T2 const &  key2,
T3 const &  key3 
)

Definition at line 388 of file dictionary_arg_stream.hpp.

◆ call_member_with_dictionary() [6/8]

arg_stream::result_type<F>::type adobe::call_member_with_dictionary ( x,
f,
std::nothrow_t  ,
Dictionary const &  dict,
T1 const &  key1,
T2 const &  key2,
T3 const &  key3 
)

Definition at line 408 of file dictionary_arg_stream.hpp.

◆ call_member_with_dictionary() [7/8]

arg_stream::result_type<F>::type adobe::call_member_with_dictionary ( X &  x,
f,
Dictionary const &  dict,
T1 const &  key1,
T2 const &  key2,
T3 const &  key3,
T4 const &  key4 
)

Definition at line 429 of file dictionary_arg_stream.hpp.

◆ call_member_with_dictionary() [8/8]

arg_stream::result_type<F>::type adobe::call_member_with_dictionary ( x,
f,
std::nothrow_t  ,
Dictionary const &  dict,
T1 const &  key1,
T2 const &  key2,
T3 const &  key3,
T4 const &  key4 
)

Definition at line 449 of file dictionary_arg_stream.hpp.

◆ call_with_dictionary() [1/7]

arg_stream::result_type<F>::type adobe::call_with_dictionary ( f,
std::nothrow_t  ,
Dictionary const &  dict,
SingleArg const &  key_or_key_range 
)

Definition at line 313 of file dictionary_arg_stream.hpp.

◆ call_with_dictionary() [2/7]

arg_stream::result_type<F>::type adobe::call_with_dictionary ( f,
Dictionary const &  dict,
T1 const &  key1,
T2 const &  key2 
)

Definition at line 337 of file dictionary_arg_stream.hpp.

◆ call_with_dictionary() [3/7]

arg_stream::result_type<F>::type adobe::call_with_dictionary ( f,
std::nothrow_t  ,
Dictionary const &  dict,
T1 const &  key1,
T2 const &  key2 
)

Definition at line 357 of file dictionary_arg_stream.hpp.

◆ call_with_dictionary() [4/7]

arg_stream::result_type<F>::type adobe::call_with_dictionary ( f,
Dictionary const &  dict,
T1 const &  key1,
T2 const &  key2,
T3 const &  key3 
)

Definition at line 378 of file dictionary_arg_stream.hpp.

◆ call_with_dictionary() [5/7]

arg_stream::result_type<F>::type adobe::call_with_dictionary ( f,
std::nothrow_t  ,
Dictionary const &  dict,
T1 const &  key1,
T2 const &  key2,
T3 const &  key3 
)

Definition at line 398 of file dictionary_arg_stream.hpp.

◆ call_with_dictionary() [6/7]

arg_stream::result_type<F>::type adobe::call_with_dictionary ( f,
Dictionary const &  dict,
T1 const &  key1,
T2 const &  key2,
T3 const &  key3,
T4 const &  key4 
)

Definition at line 419 of file dictionary_arg_stream.hpp.

◆ call_with_dictionary() [7/7]

arg_stream::result_type<F>::type adobe::call_with_dictionary ( f,
std::nothrow_t  ,
Dictionary const &  dict,
T1 const &  key1,
T2 const &  key2,
T3 const &  key3,
T4 const &  key4 
)

Definition at line 439 of file dictionary_arg_stream.hpp.

◆ child_begin()

child_iterator<I> adobe::child_begin ( const I &  x)

Definition at line 995 of file forest.hpp.

◆ child_end()

child_iterator<I> adobe::child_end ( const I &  x)

Definition at line 1001 of file forest.hpp.

◆ construct() [1/2]

void adobe::construct ( T *  p)

Definition at line 629 of file memory.hpp.

◆ construct() [2/2]

void adobe::construct ( T *  p,
x 
)

Definition at line 632 of file memory.hpp.

◆ current_exception_what()

const char* adobe::current_exception_what ( )

Definition at line 38 of file function.hpp.

◆ datoi()

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

decimal atoi

Iterator-based atoi

Definition at line 1271 of file xml_parser.hpp.

◆ destroy() [1/2]

void adobe::destroy ( T *  p)

Definition at line 626 of file memory.hpp.

◆ destroy() [2/2]

void adobe::destroy ( f,
l 
)

Definition at line 635 of file memory.hpp.

◆ end_alternate()

format_base::stream_type& adobe::end_alternate ( format_base::stream_type os)

◆ end_atom()

◆ end_bag()

◆ end_format()

format_base::stream_type& adobe::end_format ( format_base::stream_type os)

◆ end_sequence()

format_base::stream_type& adobe::end_sequence ( format_base::stream_type os)

◆ eof_token()

E adobe::eof_token ( )

◆ find_edge()

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

Definition at line 97 of file forest.hpp.

◆ find_edge_reverse()

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

Definition at line 100 of file forest.hpp.

◆ find_parent()

I adobe::find_parent ( i)

Definition at line 64 of file forest.hpp.

◆ format_base_idx()

int adobe::format_base_idx ( )

◆ format_stream_error() [1/2]

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

◆ format_stream_error() [2/2]

std::string adobe::format_stream_error ( const stream_error_t )

◆ get_dictionary_entry()

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

Definition at line 59 of file dictionary_arg_stream.hpp.

◆ get_formatter()

format_base* adobe::get_formatter ( std::ostream &  os)

◆ get_line()

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

Definition at line 294 of file istream.hpp.

◆ has_children()

bool adobe::has_children ( const I &  i)

Definition at line 73 of file forest.hpp.

◆ is_line_end() [1/2]

bool adobe::is_line_end ( I &  first,
last 
)

Definition at line 252 of file istream.hpp.

◆ is_line_end() [2/2]

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

Definition at line 270 of file istream.hpp.

◆ layout_variables()

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

◆ leading_of()

I adobe::leading_of ( i)

Definition at line 56 of file forest.hpp.

◆ lower_bound_n() [1/3]

I adobe::lower_bound_n ( f,
n,
const T &  x 
)

Definition at line 70 of file lower_bound.hpp.

◆ lower_bound_n() [2/3]

I adobe::lower_bound_n ( f,
n,
const T &  x,
c 
)

Definition at line 81 of file lower_bound.hpp.

◆ lower_bound_n() [3/3]

I adobe::lower_bound_n ( f,
n,
const T &  x,
c,
p 
)

Definition at line 93 of file lower_bound.hpp.

◆ make_dictionary_arg_stream() [1/2]

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

Definition at line 168 of file dictionary_arg_stream.hpp.

◆ make_dictionary_arg_stream() [2/2]

dictionary_arg_stream<Dictionary, InputRange, std::nothrow_t> adobe::make_dictionary_arg_stream ( Dictionary &  dict,
InputRange const &  key_range,
std::nothrow_t   
)

Definition at line 176 of file dictionary_arg_stream.hpp.

◆ mismatch()

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

Definition at line 60 of file mismatch.hpp.

◆ mismatch_n()

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

Definition at line 46 of file mismatch.hpp.

◆ operator!=()

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

Definition at line 719 of file forest.hpp.

◆ operator<<() [1/3]

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

◆ operator<<() [2/3]

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

◆ operator<<() [3/3]

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

◆ operator==() [1/2]

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

Definition at line 421 of file circular_queue.hpp.

◆ operator==() [2/2]

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

Definition at line 702 of file forest.hpp.

◆ pivot()

void adobe::pivot ( I &  i)
related

Definition at line 48 of file forest.hpp.

◆ pivot_of()

I adobe::pivot_of ( i)
related

Definition at line 51 of file forest.hpp.

◆ runtime_cast() [1/3]

R adobe::runtime_cast ( T &  x)

Definition at line 66 of file conversion.hpp.

◆ runtime_cast() [2/3]

R adobe::runtime_cast ( T *  x)

Definition at line 70 of file conversion.hpp.

◆ runtime_cast() [3/3]

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

Definition at line 74 of file conversion.hpp.

◆ strcmp()

int adobe::strcmp ( const char *  x,
const char *  y 
)

Definition at line 22 of file cstring.hpp.

◆ swap() [1/2]

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

◆ swap() [2/2]

void swap ( forest< T > &  x,
forest< T > &  y 
)

Definition at line 828 of file forest.hpp.

◆ to_utf16()

boost::enable_if<is_utf16_iterator_type<I>, O>::type adobe::to_utf16 ( first,
last,
output 
)

Definition at line 514 of file unicode.hpp.

◆ to_utf8() [1/2]

boost::enable_if<is_utf32_iterator_type<I>, O>::type adobe::to_utf8 ( first,
last,
output 
)

Definition at line 428 of file unicode.hpp.

◆ to_utf8() [2/2]

boost::enable_if<is_utf8_iterator_type<I>, O>::type adobe::to_utf8 ( first,
last,
output 
)

Definition at line 449 of file unicode.hpp.

◆ trailing_of()

I adobe::trailing_of ( i)

Definition at line 59 of file forest.hpp.

◆ uninitialized_move()

F adobe::uninitialized_move ( f,
l,
r 
)

Similar to std::uninitialized_copy but with move semantics.

Definition at line 650 of file memory.hpp.

◆ upper_bound_n() [1/3]

I adobe::upper_bound_n ( f,
n,
const T &  x 
)

Definition at line 74 of file upper_bound.hpp.

◆ upper_bound_n() [2/3]

I adobe::upper_bound_n ( f,
n,
const T &  x,
c 
)

Definition at line 85 of file upper_bound.hpp.

◆ upper_bound_n() [3/3]

I adobe::upper_bound_n ( f,
n,
const T &  x,
c,
p 
)

Definition at line 97 of file upper_bound.hpp.

◆ value_to_utf16()

boost::enable_if<is_utf32_type<T>, O>::type adobe::value_to_utf16 ( code,
output 
)

Definition at line 464 of file unicode.hpp.

◆ value_to_utf8() [1/3]

boost::enable_if<is_utf32_type<T>, O>::type adobe::value_to_utf8 ( code,
output 
)

Definition at line 344 of file unicode.hpp.

◆ value_to_utf8() [2/3]

boost::enable_if<is_utf16_type<T>, O>::type adobe::value_to_utf8 ( code,
output 
)

Definition at line 372 of file unicode.hpp.

◆ value_to_utf8() [3/3]

boost::enable_if<is_utf8_type<T>, O>::type adobe::value_to_utf8 ( code,
output 
)

Definition at line 387 of file unicode.hpp.

◆ xatoi()

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

hexadecimal atoi

Iterator-based atoi, but for hexadecimal number strings.

Definition at line 1237 of file xml_parser.hpp.

◆ xml_element_echo()

token_range_t adobe::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 622 of file xml_parser.hpp.

◆ xml_element_linefeed()

token_range_t adobe::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 638 of file xml_parser.hpp.

◆ xml_element_strip()

token_range_t adobe::xml_element_strip ( const token_range_t ,
const token_range_t ,
const attribute_set_t ,
const token_range_t value 
)

Definition at line 630 of file xml_parser.hpp.

Variable Documentation

◆ add_k

◆ alt_name_g

const aggregate_name_t alt_name_g
static

Definition at line 49 of file iomanip.hpp.

◆ and_k

◆ array_k

◆ assign_k

aggregate_name_t assign_k

◆ at_k

◆ atom_name_g

const aggregate_name_t atom_name_g
static

Definition at line 50 of file iomanip.hpp.

◆ bag_name_g

const aggregate_name_t bag_name_g
static

Definition at line 47 of file iomanip.hpp.

◆ close_brace_k

aggregate_name_t close_brace_k

◆ close_bracket_k

aggregate_name_t close_bracket_k

◆ close_parenthesis_k

aggregate_name_t close_parenthesis_k

◆ colon_k

◆ comma_k

◆ dictionary_k

aggregate_name_t dictionary_k

◆ divide_k

aggregate_name_t divide_k

◆ dot_k

◆ empty_k

◆ eof_k

◆ equal_k

◆ false_k

◆ function_k

aggregate_name_t function_k

◆ greater_equal_k

aggregate_name_t greater_equal_k

◆ greater_k

aggregate_name_t greater_k

◆ identifier_k

aggregate_name_t identifier_k

◆ ifelse_k

aggregate_name_t ifelse_k

◆ index_k

◆ is_k

◆ keyword_k

aggregate_name_t keyword_k

◆ lead_comment_k

aggregate_name_t lead_comment_k

◆ less_equal_k

aggregate_name_t less_equal_k

◆ less_k

◆ modulus_k

aggregate_name_t modulus_k

◆ multiply_k

aggregate_name_t multiply_k

◆ not_equal_k

aggregate_name_t not_equal_k

◆ not_k

◆ number_k

aggregate_name_t number_k

◆ open_brace_k

aggregate_name_t open_brace_k

◆ open_bracket_k

aggregate_name_t open_bracket_k

◆ open_parenthesis_k

aggregate_name_t open_parenthesis_k

◆ or_k

◆ question_k

aggregate_name_t question_k

◆ semicolon_k

aggregate_name_t semicolon_k

◆ seq_name_g

const aggregate_name_t seq_name_g
static

Definition at line 48 of file iomanip.hpp.

◆ string_k

aggregate_name_t string_k

◆ subtract_k

aggregate_name_t subtract_k

◆ to_k

◆ trail_comment_k

aggregate_name_t trail_comment_k

◆ true_k

◆ unary_negate_k

aggregate_name_t unary_negate_k

◆ variable_k

aggregate_name_t variable_k

Copyright © 2006-2007 Adobe Systems Incorporated.

Use of this website signifies your agreement to the Terms of Use and Online Privacy Policy.

Search powered by Google