Adobe Systems Incorporated



struct  chain< ArgStreamFirst, ArgStreamSecond >
 chain 2 arg_streams together by calling the first stream until depleted, then calling the second. More...
struct  dictionary_arg_stream< Dictionary, InputRange, NoThrow >
 dictionary_arg_stream implements the arg_stream interface More...
struct  no_more_args
struct  result_type< F >
 result_type<F>::type is the return type of the function f. More...
struct  signature< F >
 returns the function signature of the callable object type F More...
struct  traits< T >
 defines any traits that help with the implementation of arg_stream::call() and/or helper objects like arg_stream::chain. More...


template<typename F , typename ArgStream >
result_type< F >::type call (F f, ArgStream &astream)
template<class T , typename F , typename ArgStream >
result_type< F >::type call (T *that, F f, ArgStream &astream)
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 ArgStream >
bool eof (ArgStream const &as)
template<typename R >
get_dictionary_entry (adobe::dictionary_t const &dict, adobe::name_t const &key)
template<typename R , typename ArgStream >
get_next_arg (ArgStream const &as)

Detailed Description

arg_stream is a namespace wrapping together the concept of a stream from which you can retrieve items (ie function arguments) of various types.

An arg_stream is any object which implements a templatized member function

    template <typename R> R get_next_arg();

and (optionally) implements

    bool eof();

arg_stream implementors can communicate that they have an eof function by specializing arg_stream::traits<T>::has_eof_memberfunction.

namespace adobe { namespace arg_stream {
    template <typename>
    struct traits<my_arg_stream_goes_here>
        static const bool has_eof_memberfunction = true;
} }

Alternatively, you may rely on the default implementation of traits<T>, which uses compile time type inspection to determine if T has an eof function.

The point of arg_stream is the arg_stream::call() function:

    template<typename F, typename ArgStream>
    result_type<F>::type arg_stream::call(F f, ArgStream argstream);

Function Documentation

result_type<F>::type adobe::arg_stream::call ( f,
ArgStream &  astream 

Calls function/callable-object f with function arguments supplied by the arg_stream.

This is the point of arg_stream. To call a function with typed-args pulled out of some abstracted object.

Definition at line 306 of file arg_stream.hpp.

result_type<F>::type adobe::arg_stream::call ( T *  that,
ArgStream &  astream 

specialization of arg_stream::call for handling member function calls.

Definition at line 318 of file arg_stream.hpp.

arg_stream::result_type<F>::type adobe::call_with_dictionary ( 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

Definition at line 305 of file dictionary_arg_stream.hpp.

bool adobe::arg_stream::eof ( ArgStream const &  as )

arg_stream::eof(argstream) returns true if there are no more args available.

This function is available for specialization by arg_streams. If not specialized, the default implementation attempts to call the arg_stream's member function eof() if one is available. If there is no member function, it returns false - ie if it is not known, then it is assumed that more args exist, and thus we must still always consider that the arg_stream::no_more_args exception may be thrown.

Definition at line 168 of file arg_stream.hpp.

R adobe::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.

we use 'get_dictionary_entry' instead of the standard adobe::get_value because
    get_value(dict, key).cast<R>();
Seems a bit too specific of an interface to ask someone to implement

Definition at line 53 of file dictionary_arg_stream.hpp.

R adobe::arg_stream::get_next_arg ( ArgStream const &  as )

arg_stream::get_next_arg<T>(argstream) returns the next arg as a T

This function is what defines something as an arg_stream. An arg_stream must either: 1. implement a templatized member function get_next_arg<T>() or 2. specialize arg_stream::get_next_arg<T>(YourArgStream & argstream) ie If not specialized, this default implementation attempts to call the arg_stream's member function get_next_arg<T>(). If there is no member function, and the global function is not specialized, it will not compile.

Definition at line 186 of file arg_stream.hpp.

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