Documentation Overview Building ASL Documentation Library Wiki Docs Indices Browse Perforce More Info Release Notes Wiki Site Search License Success Stories Contributors Media Download Perforce Depots Support ASL SourceForge Home Mailing Lists Discussion Forums Report Bugs Suggest Features Contribute to ASL RSS Short-text news Full-text news File releases Other Adobe Projects Adobe Air Adobe GIL C++ Benchmarks Adobe Labs Adobe Media Gallery Adobe XMP Tamarin project (Mozilla Foundation) Other Resources Boost RIAForge SGI STL

arg_stream.hpp Go to the documentation of this file. /************************************************************************* * * ADOBE CONFIDENTIAL * ___________________ * * Copyright 2008 Adobe Systems Incorporated * All Rights Reserved. * * NOTICE: All information contained herein is, and remains * the property of Adobe Systems Incorporated and its suppliers, * if any. The intellectual and technical concepts contained * herein are proprietary to Adobe Systems Incorporated and its * suppliers and may be covered by U.S. and Foreign Patents, * patents in process, and are protected by trade secret or copyright law. * Dissemination of this information or reproduction of this material * is strictly forbidden unless prior written permission is obtained * from Adobe Systems Incorporated. **************************************************************************/ #ifndef ADOBE_ARG_STREAM_H #define ADOBE_ARG_STREAM_H #include <boost/function_types/result_type.hpp> #include <boost/function_types/function_type.hpp> #include <boost/function_types/function_arity.hpp> #include <boost/mpl/begin.hpp> #include <boost/mpl/end.hpp> #include <boost/mpl/next.hpp> #include <boost/mpl/deref.hpp> // Apple sucks #ifdef nil #undef nil #endif #include <boost/fusion/include/push_back.hpp> #include <boost/fusion/include/cons.hpp> #include <boost/fusion/include/invoke.hpp> #include <boost/type_traits/remove_cv.hpp> #include <boost/type_traits/remove_reference.hpp> #include <boost/type_traits/add_pointer.hpp> #include <boost/utility/enable_if.hpp> #include <adobe/type_inspection.hpp> // ADOBE_HAS_TYPE/ADOBE_HAS_MEMBER // forward declare boost::function so we can specialize against it namespace boost { template <typename F> class function; } namespace adobe { namespace arg_stream { struct no_more_args : std::exception { }; namespace detail { ADOBE_HAS_TYPE_IMPL(eof); template <typename T> struct has_eof_member { static const bool value = ADOBE_HAS_TYPE(T, eof); }; } template <typename T> struct traits { static const bool has_eof_member = detail::has_eof_member<T>::value; }; namespace detail { template <class ArgStream> static bool eof_check(ArgStream & as, typename boost::enable_if_c<traits<ArgStream>::has_eof_memberfunction>::type * dummy = 0) { return as.eof(); } template <class ArgStream> static bool eof_check(ArgStream & as, typename boost::disable_if_c<traits<ArgStream>::has_eof_memberfunction>::type * dummy = 0) { return false; } template <class ArgStream> static bool eof_check(ArgStream *as) { return as ? eof_check(*as) : true; } } template <typename ArgStream> bool eof(ArgStream const & as) { return detail::eof_check(as); } template <typename R, typename ArgStream> R get_next_arg(ArgStream const & as) { return as.get_next_arg<R>(); } // specialize these or let them fallback to the above specialization template <typename R, typename ArgStream> R get_next_arg(ArgStream & as) { return as.get_next_arg<R>(); } template <typename R, typename ArgStream> R get_next_arg(ArgStream * as) { return get_next_arg<R>(*as); } template <typename R, typename ArgStream> R get_next_arg(ArgStream const * as) { return get_next_arg<R>(*as); } // for some reason boost::function_types does not handle boost::functions, // nor does boost::function have a function::signature typedef, // so in order to support boost, we use this signature<F>::type mechanism: template <typename F> struct signature { typedef F type; }; // specialize for boost::function template <typename F> struct signature<boost::function<F> > { typedef F type; }; template <typename F> struct result_type { typedef typename boost::function_types::result_type<typename signature<F>::type>::type type; }; namespace detail { // how it all works... template<typename T> struct remove_cv_ref : boost::remove_cv< typename boost::remove_reference<T>::type > { }; // see also boost::function_types 'interpreter' example // we convert the function signature into a mpl sequence (it *is* an mpl sequence, since it implements mpl::begin/end/etc) // we recursively push the args onto a fusion sequence, calling get_next_arg as we go. // the recursion ends when we get to the end of the mpl-sequence-function-sigature // (see the specialized case where From == To) // and then luckily fusion has a magic invoke function we can use template< typename F, class From = typename boost::mpl::begin< boost::function_types::parameter_types<typename signature<F>::type> >::type, class To = typename boost::mpl::end< boost::function_types::parameter_types<typename signature<F>::type> >::type> struct invoker { // add an argument to a Fusion cons-list for each parameter type template<typename Args, typename ArgStream> static inline typename result_type<F>::type apply(F func, ArgStream & astream, Args const & args) { typedef typename remove_cv_ref<typename boost::mpl::deref<From>::type>::type arg_type; typedef typename boost::mpl::next<From>::type next_iter_type; return invoker<F, next_iter_type, To>::apply( func, astream, boost::fusion::push_back(args, get_next_arg<arg_type>(astream)) ); } }; // specialize final case template<typename F, class To> struct invoker<F,To,To> { template<typename Args, typename ArgStream> static inline typename result_type<F>::type apply(F func, ArgStream &, Args const & args) { return boost::fusion::invoke(func, args); } }; } // detail template <typename F, typename ArgStream> typename result_type<F>::type call(F f, ArgStream & astream) { return detail::invoker<F>::template apply(f, astream, boost::fusion::nil()); } template <class T, typename F, typename ArgStream> typename result_type<F>::type call(T * that, F f, ArgStream & astream) { // object gets pushed on as first arg of fusion list, // and remove first arg from signature (the object that the member function belongs to) using mpl::next boost::fusion::nil args; return detail::invoker<F, typename boost::mpl::next< typename boost::mpl::begin< boost::function_types::parameter_types<typename signature<F>::type, boost::add_pointer<boost::mpl::placeholders::_> > >::type>::type, typename boost::mpl::end< boost::function_types::parameter_types<typename signature<F>::type, boost::add_pointer<boost::mpl::placeholders::_> > >::type> ::template apply(f, astream, boost::fusion::push_back(args, that)); } template <typename ArgStreamFirst, typename ArgStreamSecond> struct chain { template <class ArgStream> bool eof(ArgStream * as) { return detail::eof_check(as); } typedef ArgStreamFirst first_type; typedef ArgStreamSecond second_type; ArgStreamFirst * first; ArgStreamSecond * second; chain(ArgStreamFirst & first_stream, ArgStreamSecond & second_stream) : first(&first_stream), second(&second_stream) { } template <typename T> T get_next_arg() { if (!eof(first)) { try { return first->get_next_arg<T>(); } catch(arg_stream::no_more_args &) { first = 0; } } return second->get_next_arg<T>(); } bool eof() const { return eof(first) && eof(second); } }; template <typename S1, typename S2> struct traits<chain<S1, S2> > { static const bool has_eof_memberfunction = true; }; template <typename ArgStreamFirst, typename ArgStreamSecond> chain<ArgStreamFirst, ArgStreamSecond> make_chain(ArgStreamFirst & first_stream, ArgStreamSecond & second_stream) { return chain<ArgStreamFirst, ArgStreamSecond>(first_stream, second_stream); } struct nonarg { bool eof() { return true; } template <typename R> R get_next_arg() { throw arg_stream::no_more_args(); return *(R*)32; // some compilers need a return; here's a bad one (but that doesn't require default construction) } }; template<> struct traits<nonarg> { static const bool has_eof_memberfunction = true; }; template <typename T> struct single { typedef T value_type; T value; unsigned int repeat; // yep, unsigned. single(typename boost::add_reference<T const>::type t, unsigned int count = 1) : value(t), repeat(count) { } bool eof() { return repeat == 0; } template <typename R> R convert_or_throw(value_type & value, typename boost::enable_if<boost::is_convertible<value_type, R> >::type * dummy = 0) { return R(value); } template <typename R> R convert_or_throw(value_type & value, typename boost::disable_if<boost::is_convertible<value_type, R> >::type * dummy = 0) { throw adobe::bad_cast(); return *(R*)value; } template <typename R> R get_next_arg() { if (repeat) { repeat--; } else { throw arg_stream::no_more_args(); } return convert_or_throw<R>(value); } }; template<typename T> struct traits<single<T> > { static const bool has_eof_memberfunction = true; }; template <typename ArgStream, typename Transformer> struct with_transform { ADOBE_HAS_TEMPLATE1_IMPL(arg_stream_inverse_lookup); template <typename Class> struct has_inverse_lookup { static const bool value = ADOBE_HAS_TEMPLATE1(Class, arg_stream_inverse_lookup); }; template <typename Class, typename R, bool> struct has_entry_if_has_inverse_lookup { static const bool value = false; }; template <typename Class, typename R> struct has_entry_if_has_inverse_lookup<Class, R, true> { static const bool value = has_type_type<typename Class::template arg_stream_inverse_lookup<R> >::value; }; template <typename Class, typename R> struct has_transform { static const bool value = has_entry_if_has_inverse_lookup<Class, R, has_inverse_lookup<Class>::value>::value; }; typedef ArgStream value_type; typedef ArgStream arg_stream_type; typedef Transformer transformer_type; ArgStream & argstream; Transformer & transformer; with_transform(ArgStream & as, Transformer & trans) : argstream(as), transformer(trans) { } bool eof() { return detail::eof_check(argstream); } template <typename R> R transforming_get(typename boost::enable_if<has_transform<Transformer, R> >::type * dummy = 0) { typedef typename Transformer::template arg_stream_inverse_lookup<R>::type Rfrom; return transformer.template arg_stream_transform<R>(arg_stream::get_next_arg<Rfrom>(argstream)); } template <typename R> R transforming_get(typename boost::disable_if<has_transform<Transformer, R> >::type * dummy = 0) { return arg_stream::get_next_arg<R>(argstream); } template <typename R> R get_next_arg() { return transforming_get<R>(); } }; template <typename ArgStream, typename Transformer> with_transform<ArgStream, Transformer> make_transforming(ArgStream & as, Transformer & transformer) { return with_transform<ArgStream, Transformer>(as, transformer); } } // namespace arg_stream } // namespace adobe #endif // include_guard

• Company | 
• Online Privacy Policy | 
• Terms of Use | 
• Contact Us | 
• Accessibility | 
• Report Piracy | 
• Permissions & Trademarks | 
• Product License Agreements | 
• Send Feedback

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